filename
stringlengths 3
67
| data
stringlengths 0
58.3M
| license
stringlengths 0
19.5k
|
|---|---|---|
sum.ml |
type ('a, 'b) sum =
| Inl of 'a
| Inr of 'b
| |
config.ml | (***********************************************************************)
(** **)
(** WARNING WARNING WARNING **)
(** **)
(** When you change this file, you must make the parallel change **)
(** in config.mlbuild **)
(** **)
(***********************************************************************)
(* The main OCaml version string has moved to ../VERSION *)
let version = Sys.ocaml_version
let flambda = false
let exec_magic_number = "Caml1999X032"
(* exec_magic_number is duplicated in runtime/caml/exec.h *)
and cmi_magic_number = "Caml1999I032"
and cmo_magic_number = "Caml1999O032"
and cma_magic_number = "Caml1999A032"
and cmx_magic_number =
if flambda then
"Caml1999y032"
else
"Caml1999Y032"
and cmxa_magic_number =
if flambda then
"Caml1999z032"
else
"Caml1999Z032"
and ast_impl_magic_number = "Caml1999M032"
and ast_intf_magic_number = "Caml1999N032"
and cmxs_magic_number = "Caml1999D032"
and cmt_magic_number = "Caml1999T032"
let interface_suffix = ref ".mli"
let max_tag = 245
let flat_float_array = false
let merlin = true
| (**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
|
options.mli | (*s Common options to bib2bib and bibtex2html. *)
val debug : bool ref
val quiet : bool ref
val warn_error : bool ref
| (**************************************************************************)
(* bibtex2html - A BibTeX to HTML translator *)
(* Copyright (C) 1997-2014 Jean-Christophe Filliâtre and Claude Marché *)
(* *)
(* This software is free software; you can redistribute it and/or *)
(* modify it under the terms of the GNU General Public *)
(* License version 2, as published by the Free Software Foundation. *)
(* *)
(* This software is distributed in the hope that it will be useful, *)
(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *)
(* *)
(* See the GNU General Public License version 2 for more details *)
(* (enclosed in the file GPL). *)
(**************************************************************************)
|
opam_file.ml |
let upgrade ~filename ~url ~id ~version opam_t =
let commit_hash =
{
OpamParserTypes.FullPos.pelem = OpamParserTypes.FullPos.String id;
pos = OpamTypesBase.pos_file filename;
}
in
match version with
| `V1 descr ->
opam_t |> OpamFormatUpgrade.opam_file_from_1_2_to_2_0
|> OpamFile.OPAM.with_url url
|> OpamFile.OPAM.with_descr descr
|> OpamFile.OPAM.with_version_opt None
|> OpamFile.OPAM.with_name_opt None
|> fun x -> OpamFile.OPAM.add_extension x "x-commit-hash" commit_hash
| `V2 ->
opam_t |> OpamFile.OPAM.with_url url
|> OpamFile.OPAM.with_version_opt None
|> OpamFile.OPAM.with_name_opt None
|> fun x -> OpamFile.OPAM.add_extension x "x-commit-hash" commit_hash
| |
test_bvarith_buffers.c |
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <inttypes.h>
#include <assert.h>
#include "terms/bv_constants.h"
#include "terms/bvarith_buffers.h"
#include "terms/pprod_table.h"
#include "utils/object_stores.h"
/*
* Display power products
*/
static void print_varexp_array(FILE *f, varexp_t *a, uint32_t n) {
uint32_t i, d;
if (n == 0) {
fprintf(f, "1");
return;
}
d = a[0].exp;
fprintf(f, "x_%"PRId32, a[0].var);
if (d != 1) {
fprintf(f, "^%"PRIu32, d);
}
for (i=1; i<n; i++) {
d = a[i].exp;
fprintf(f, " x_%"PRId32, a[i].var);
if (d != 1) {
fprintf(f, "^%"PRIu32, d);
}
}
}
static void print_pprod0(FILE *f, pprod_t *p) {
if (pp_is_var(p)) {
fprintf(f, "x_%"PRId32, var_of_pp(p));
} else if (pp_is_empty(p)) {
fprintf(f, "1");
} else {
print_varexp_array(f, p->prod, p->len);
}
}
/*
* Print buffer b
*/
static void print_bv_monomial(FILE *f, uint32_t *coeff, pprod_t *r, uint32_t n, bool first) {
if (! first) {
fprintf(f, " + ");
}
bvconst_print(f, coeff, n);
if (! pp_is_empty(r)) {
fprintf(f, " ");
print_pprod0(f, r);
}
}
static void print_bvarith_buffer(FILE *f, bvarith_buffer_t *b) {
bvmlist_t *p;
bool first;
if (bvarith_buffer_is_zero(b)) {
fprintf(f, "0");
} else {
p = b->list;
first = true;
while (p->next != NULL) {
print_bv_monomial(f, p->coeff, p->prod, b->bitsize, first);
first = false;
p = p->next;
}
}
}
/*
* Test basic operations: b must be normalized
*/
static void test_buffer_pred(char *s, bvarith_buffer_t *b, bool (*f)(bvarith_buffer_t *)) {
printf(" test %s: ", s);
if (f(b)) {
printf("yes\n");
} else {
printf("no\n");
}
}
static void test_buffer(bvarith_buffer_t *b) {
bvmlist_t *m;
printf("Buffer %p: ", b);
print_bvarith_buffer(stdout, b);
printf("\n");
test_buffer_pred("is_zero", b, bvarith_buffer_is_zero);
test_buffer_pred("is_constant", b, bvarith_buffer_is_constant);
printf(" size: %"PRIu32"\n", bvarith_buffer_size(b));
printf(" bitsize: %"PRIu32"\n", bvarith_buffer_bitsize(b));
printf(" width: %"PRIu32"\n", bvarith_buffer_width(b));
printf(" degree: %"PRIu32"\n", bvarith_buffer_degree(b));
if (! bvarith_buffer_is_zero(b)) {
printf(" main term: ");
print_pprod0(stdout, bvarith_buffer_main_term(b));
printf("\n");
m = bvarith_buffer_main_mono(b);
printf(" main monomial: ");
bvconst_print(stdout, m->coeff, b->bitsize);
printf(" * ");
print_pprod0(stdout, m->prod);
printf("\n");
}
printf("---\n");
}
/*
* Global variables:
* - global prod table and store
*/
static pprod_table_t prod_table;
static object_store_t store;
/*
* Initialize table and store
*/
static void init_globals(void) {
init_bvconstants();
init_bvmlist_store(&store);
init_pprod_table(&prod_table, 0);
}
/*
* Delete table and store
*/
static void delete_globals(void) {
delete_pprod_table(&prod_table);
delete_bvmlist_store(&store);
cleanup_bvconstants();
}
/*
* Tests: one buffer
* - n = bitsize
*/
static void test1(uint32_t n) {
bvarith_buffer_t buffer;
uint32_t q0[4];
assert(0 < n && n <= 128);
init_bvarith_buffer(&buffer, &prod_table, &store);
bvarith_buffer_prepare(&buffer, n);
printf("Empty buffer\n");
test_buffer(&buffer);
printf("x_0 + x_1\n");
bvarith_buffer_add_var(&buffer, 0);
bvarith_buffer_add_var(&buffer, 1);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("After reset\n");
bvarith_buffer_prepare(&buffer, n);
test_buffer(&buffer);
printf("x_2 - x_0\n");
bvarith_buffer_add_var(&buffer, 2);
bvarith_buffer_sub_var(&buffer, 0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("x_2 - x_0 + x_1 + x_0\n");
bvarith_buffer_prepare(&buffer, n);
bvarith_buffer_add_var(&buffer, 2);
bvarith_buffer_sub_var(&buffer, 0);
bvarith_buffer_add_var(&buffer, 1);
bvarith_buffer_add_var(&buffer, 0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Adding 3\n");
bvconst_set32(q0, 4, 3);
bvarith_buffer_add_const(&buffer, q0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Negating\n");
bvarith_buffer_negate(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Negating again\n");
bvarith_buffer_negate(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Multiplying by 2 x_4\n");
bvconst_set32(q0, 4, 2);
bvarith_buffer_mul_varmono(&buffer, q0, 4);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Multiplying by x_1^2\n");
bvarith_buffer_mul_var(&buffer, 1);
bvarith_buffer_mul_var(&buffer, 1);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Multiplying by 0\n");
bvconst_clear(q0, 4);
bvarith_buffer_mul_const(&buffer, q0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("x_1 + 1 - x_2\n");
bvarith_buffer_prepare(&buffer, n);
bvarith_buffer_add_var(&buffer, 1);
bvconst_set32(q0, 4, 1);
bvarith_buffer_add_const(&buffer, q0);
bvarith_buffer_sub_var(&buffer, 2);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Squaring\n");
bvarith_buffer_square(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Squaring\n");
bvarith_buffer_square(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Squaring\n");
bvarith_buffer_square(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
delete_bvarith_buffer(&buffer);
}
/*
* Test2: binary operations
*/
/*
* Array of buffers for test2
*/
#define NUM_BUFFERS 8
static bvarith_buffer_t aux[NUM_BUFFERS];
/*
* Initialize the buffers:
* - n = bitsize
*/
static void init_test2(uint32_t n) {
uint32_t q0[4];
uint32_t i;
assert(0 < n && n <= 128);
for (i=0; i<8; i++) {
init_bvarith_buffer(aux + i, &prod_table, &store);
bvarith_buffer_prepare(aux + i, n);
}
bvarith_buffer_add_var(&aux[0], 3); // x_3
bvconst_set32(q0, 4, 2);
bvarith_buffer_add_const(&aux[1], q0); // 2
bvarith_buffer_add_var(&aux[2], 1);
bvarith_buffer_sub_var(&aux[2], 2); // x_1 - x_2
bvarith_buffer_add_var(&aux[3], 0);
bvarith_buffer_sub_const(&aux[3], q0); // x_0 - 2
bvarith_buffer_add_pp(&aux[4], pprod_mul(&prod_table, var_pp(1), var_pp(1))); // x_1^2
bvarith_buffer_add_var(&aux[5], 0);
bvarith_buffer_mul_const(&aux[5], q0); // 2 * x_0
bvarith_buffer_add_varmono(&aux[6], q0, 1); // 2 * x_1
bvarith_buffer_sub_var(&aux[7], 3);
bvarith_buffer_sub_var(&aux[7], 3);
bvarith_buffer_add_var(&aux[7], 4);
for (i=0; i<8; i++) {
bvarith_buffer_normalize(aux + i);
}
}
/*
* Delete the buffers
*/
static void delete_test2(void) {
uint32_t i;
for (i=0; i<8; i++) {
delete_bvarith_buffer(aux + i);
}
}
/*
* Test binary operations with b1 and b2
*/
static void test_ops(bvarith_buffer_t *b1, bvarith_buffer_t *b2) {
bvarith_buffer_t b;
uint32_t n;
assert(b1->bitsize == b2->bitsize);
printf("b1: ");
print_bvarith_buffer(stdout, b1);
printf("\nb2: ");
print_bvarith_buffer(stdout, b2);
printf("\n");
printf("Equality test: ");
if (bvarith_buffer_equal(b1, b2)) {
printf("yes\n");
} else {
printf("no\n");
}
n = b1->bitsize;
init_bvarith_buffer(&b, &prod_table, &store);
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b1);
bvarith_buffer_add_buffer(&b, b2);
bvarith_buffer_normalize(&b);
printf(" b1 + b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b1);
bvarith_buffer_sub_buffer(&b, b2);
bvarith_buffer_normalize(&b);
printf(" b1 - b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b2);
bvarith_buffer_sub_buffer(&b, b1);
bvarith_buffer_normalize(&b);
printf(" b2 - b1: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b1);
bvarith_buffer_mul_buffer(&b, b2);
bvarith_buffer_normalize(&b);
printf(" b1 * b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b2);
bvarith_buffer_mul_buffer(&b, b1);
bvarith_buffer_normalize(&b);
printf(" b2 * b1: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer_times_buffer(&b, b1, b2);
bvarith_buffer_normalize(&b);
printf(" b1 * b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_sub_buffer_times_buffer(&b, b1, b2);
bvarith_buffer_normalize(&b);
printf("- b1 * b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
delete_bvarith_buffer(&b);
printf("----\n");
}
/*
* Test 2: n = bitsize
*/
static void test2(uint32_t n) {
uint32_t i, j;
init_test2(n);
for (i=0; i<8; i++) {
for (j=0; j<8; j++) {
test_ops(aux + i, aux + j);
}
}
delete_test2();
}
int main(void) {
init_globals();
test1(5);
printf("\n\n");
test1(32);
printf("\n\n");
test1(35);
printf("\n\n");
test2(5);
printf("\n\n");
test2(32);
printf("\n\n");
test2(35);
printf("\n\n");
delete_globals();
return 0;
}
| /*
* The Yices SMT Solver. Copyright 2014 SRI International.
*
* This program may only be used subject to the noncommercial end user
* license agreement which is downloadable along with this program.
*/ |
bzlaskolemize.c |
#include "preprocess/bzlaskolemize.h"
#include "bzlacore.h"
#include "bzlaexp.h"
#include "bzlanode.h"
#include "bzlasubst.h"
#include "utils/bzlahashint.h"
#include "utils/bzlanodeiter.h"
BzlaNode *
bzla_skolemize_node(Bzla *bzla,
BzlaNode *root,
BzlaIntHashTable *node_map,
BzlaPtrHashTable *skolem_consts)
{
int32_t i;
char *symbol, *buf;
size_t j, len;
BzlaNode *cur, *real_cur, *result, *quant, *param, *uf, **e;
BzlaNodePtrStack visit, quants, args, params;
BzlaMemMgr *mm;
BzlaIntHashTable *map;
BzlaHashTableData *d, *d_p;
BzlaSortIdStack sorts;
BzlaSortId tuple_s, fun_s;
mm = bzla->mm;
map = bzla_hashint_map_new(mm);
BZLA_INIT_STACK(mm, args);
BZLA_INIT_STACK(mm, params);
BZLA_INIT_STACK(mm, quants);
BZLA_INIT_STACK(mm, sorts);
BZLA_INIT_STACK(mm, visit);
BZLA_PUSH_STACK(visit, root);
while (!BZLA_EMPTY_STACK(visit))
{
cur = BZLA_POP_STACK(visit);
real_cur = bzla_node_real_addr(cur);
// assert (!bzla_node_is_quantifier (real_cur) ||
// !bzla_node_is_inverted (cur));
d = bzla_hashint_map_get(map, real_cur->id);
if (!d)
{
bzla_hashint_map_add(map, real_cur->id);
if (bzla_node_is_forall(real_cur)) BZLA_PUSH_STACK(quants, cur);
BZLA_PUSH_STACK(visit, cur);
for (i = real_cur->arity - 1; i >= 0; i--)
BZLA_PUSH_STACK(visit, real_cur->e[i]);
}
else if (!d->as_ptr)
{
assert(BZLA_COUNT_STACK(args) >= real_cur->arity);
args.top -= real_cur->arity;
e = args.top;
if (real_cur->arity == 0)
{
if (bzla_node_is_param(real_cur))
{
symbol = bzla_node_get_symbol(bzla, real_cur);
buf = 0;
if (bzla_node_param_is_exists_var(real_cur))
{
if (symbol)
{
len = strlen(symbol) + 5;
buf = bzla_mem_malloc(mm, len);
sprintf(buf, "sk(%s)", symbol);
}
/* substitute param with skolem function */
if (BZLA_COUNT_STACK(quants) > 0)
{
for (j = 0; j < BZLA_COUNT_STACK(quants); j++)
{
quant = BZLA_PEEK_STACK(quants, j);
d_p = bzla_hashint_map_get(map, quant->e[0]->id);
assert(d_p);
assert(d_p->as_ptr);
param = d_p->as_ptr;
BZLA_PUSH_STACK(params, param);
BZLA_PUSH_STACK(sorts, param->sort_id);
}
tuple_s =
bzla_sort_tuple(bzla, sorts.start, BZLA_COUNT_STACK(sorts));
fun_s = bzla_sort_fun(bzla, tuple_s, real_cur->sort_id);
bzla_sort_release(bzla, tuple_s);
uf = bzla_exp_uf(bzla, fun_s, buf);
bzla_sort_release(bzla, fun_s);
result = bzla_exp_apply_n(
bzla, uf, params.start, BZLA_COUNT_STACK(params));
if (skolem_consts)
bzla_hashptr_table_add(skolem_consts, bzla_node_copy(bzla, uf));
bzla_node_release(bzla, uf);
BZLA_RESET_STACK(sorts);
BZLA_RESET_STACK(params);
}
/* substitute param with variable in outermost scope */
else
{
result = bzla_exp_var(bzla, real_cur->sort_id, buf);
if (skolem_consts)
bzla_hashptr_table_add(skolem_consts,
bzla_node_copy(bzla, result));
}
}
else
{
if (symbol)
{
len = strlen(symbol) + 3;
buf = bzla_mem_malloc(mm, len);
sprintf(buf, "%s!0", symbol);
}
result = bzla_exp_param(bzla, real_cur->sort_id, buf);
}
if (buf) bzla_mem_freestr(mm, buf);
}
else
result = bzla_node_copy(bzla, real_cur);
}
else if (bzla_node_is_bv_slice(real_cur))
{
result = bzla_exp_bv_slice(bzla,
e[0],
bzla_node_bv_slice_get_upper(real_cur),
bzla_node_bv_slice_get_lower(real_cur));
}
else if (bzla_node_is_exists(real_cur))
{
assert(!bzla_node_is_param(e[0]));
result = bzla_node_copy(bzla, e[1]);
}
else
result = bzla_exp_create(bzla, real_cur->kind, e, real_cur->arity);
for (i = 0; i < real_cur->arity; i++) bzla_node_release(bzla, e[i]);
d->as_ptr = bzla_node_copy(bzla, result);
if (node_map)
{
assert(!bzla_hashint_map_contains(node_map, real_cur->id));
bzla_hashint_map_add(node_map, real_cur->id)->as_int =
bzla_node_real_addr(result)->id;
}
PUSH_RESULT:
if (bzla_node_is_forall(real_cur))
{
quant = BZLA_POP_STACK(quants);
assert(quant == cur);
}
result = bzla_node_cond_invert(cur, result);
assert(!bzla_node_is_quantifier(result)
|| !bzla_node_is_inverted(result));
BZLA_PUSH_STACK(args, result);
}
else
{
assert(d->as_ptr);
result = bzla_node_copy(bzla, d->as_ptr);
goto PUSH_RESULT;
}
}
assert(BZLA_COUNT_STACK(args) == 1);
result = BZLA_POP_STACK(args);
for (j = 0; j < map->size; j++)
{
if (!map->data[j].as_ptr) continue;
bzla_node_release(bzla, map->data[j].as_ptr);
}
bzla_hashint_map_delete(map);
BZLA_RELEASE_STACK(visit);
BZLA_RELEASE_STACK(quants);
BZLA_RELEASE_STACK(params);
BZLA_RELEASE_STACK(args);
BZLA_RELEASE_STACK(sorts);
return result;
}
void
bzla_skolemize(Bzla *bzla)
{
assert(bzla->synthesized_constraints->count == 0);
assert(bzla->embedded_constraints->count == 0);
assert(bzla->varsubst_constraints->count == 0);
char *symbol, *buf;
size_t i, len;
BzlaNode *cur, *quant, *param, *uf, *app, *subst;
BzlaPtrHashTableIterator it;
BzlaNodePtrStack visit, quants, args;
BzlaMemMgr *mm;
BzlaIntHashTable *cache;
BzlaHashTableData *d;
BzlaNodeMap *map;
BzlaSortIdStack sorts;
BzlaSortId tuple_s, fun_s;
BzlaNodeMapIterator nit;
mm = bzla->mm;
cache = bzla_hashint_map_new(mm);
map = bzla_nodemap_new(bzla);
BZLA_INIT_STACK(mm, visit);
/* push roots */
bzla_iter_hashptr_init(&it, bzla->unsynthesized_constraints);
while (bzla_iter_hashptr_has_next(&it))
{
cur = bzla_iter_hashptr_next(&it);
BZLA_PUSH_STACK(visit, cur);
}
bzla_init_substitutions(bzla);
BZLA_INIT_STACK(mm, quants);
BZLA_INIT_STACK(mm, args);
BZLA_INIT_STACK(mm, sorts);
while (!BZLA_EMPTY_STACK(visit))
{
cur = bzla_node_real_addr(BZLA_POP_STACK(visit));
d = bzla_hashint_map_get(cache, cur->id);
if (!d)
{
(void) bzla_hashint_map_add(cache, cur->id);
if (bzla_node_is_forall(cur)) BZLA_PUSH_STACK(quants, cur);
BZLA_PUSH_STACK(visit, cur);
for (i = 0; i < cur->arity; i++) BZLA_PUSH_STACK(visit, cur->e[i]);
}
else if (d->as_int == 0)
{
d->as_int = 1;
if (bzla_node_is_forall(cur))
{
quant = BZLA_POP_STACK(quants);
assert(quant == cur);
}
else if (bzla_node_is_exists(cur) && BZLA_COUNT_STACK(quants) > 0)
{
param = cur->e[0];
for (i = 0; i < BZLA_COUNT_STACK(quants); i++)
{
quant = BZLA_PEEK_STACK(quants, i);
BZLA_PUSH_STACK(args, quant->e[0]);
BZLA_PUSH_STACK(sorts, quant->e[0]->sort_id);
}
tuple_s = bzla_sort_tuple(bzla, sorts.start, BZLA_COUNT_STACK(sorts));
fun_s = bzla_sort_fun(bzla, tuple_s, param->sort_id);
symbol = bzla_node_get_symbol(bzla, param);
// printf ("%s\n", symbol);
if (symbol)
{
len = strlen(symbol) + 5;
buf = bzla_mem_malloc(mm, len);
sprintf(buf, "sk(%s)", symbol);
}
else
buf = 0;
uf = bzla_exp_uf(bzla, fun_s, buf);
app = bzla_exp_apply_n(bzla, uf, args.start, BZLA_COUNT_STACK(args));
// printf ("%s -> %s\n", node2string (param), node2string
//(uf));
bzla_nodemap_map(map, param, app);
bzla_mem_freestr(mm, buf);
bzla_sort_release(bzla, tuple_s);
bzla_sort_release(bzla, fun_s);
bzla_node_release(bzla, uf);
BZLA_RESET_STACK(sorts);
BZLA_RESET_STACK(args);
}
}
}
bzla_iter_hashptr_init(&it, bzla->quantifiers);
while (bzla_iter_hashptr_has_next(&it))
{
cur = bzla_iter_hashptr_next(&it);
if (bzla_node_is_forall(cur)) continue;
/* exists quantifier in most outer scope */
if (!bzla_nodemap_mapped(map, cur->e[0])) continue;
subst = bzla_substitute_nodes(bzla, bzla_node_binder_get_body(cur), map);
bzla_nodemap_map(map, cur, subst);
assert(!bzla_hashptr_table_get(bzla->substitutions, cur));
bzla_insert_substitution(bzla, cur, subst, 0);
}
bzla_substitute_and_rebuild(bzla, bzla->substitutions);
bzla_delete_substitutions(bzla);
bzla_iter_nodemap_init(&nit, map);
while (bzla_iter_nodemap_has_next(&nit))
{
cur = bzla_iter_nodemap_next_data(&nit)->as_ptr;
bzla_node_release(bzla, cur);
}
bzla_nodemap_delete(map);
bzla_hashint_map_delete(cache);
BZLA_RELEASE_STACK(visit);
BZLA_RELEASE_STACK(quants);
BZLA_RELEASE_STACK(args);
BZLA_RELEASE_STACK(sorts);
}
| /***
* Bitwuzla: Satisfiability Modulo Theories (SMT) solver.
*
* This file is part of Bitwuzla.
*
* Copyright (C) 2007-2022 by the authors listed in the AUTHORS file.
*
* See COPYING for more information on using this software.
*/ |
block_hash.mli | (** Blocks hashes / IDs. *)
include S.HASH
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
test_circuit.mli | (*_ This signature is deliberately empty. *)
| (*_ This signature is deliberately empty. *)
|
contract_storage.ml | type error +=
| Balance_too_low of Contract_repr.contract * Tez_repr.t * Tez_repr.t (* `Temporary *)
| Counter_in_the_past of Contract_repr.contract * Z.t * Z.t (* `Branch *)
| Counter_in_the_future of Contract_repr.contract * Z.t * Z.t (* `Temporary *)
| Unspendable_contract of Contract_repr.contract (* `Permanent *)
| Non_existing_contract of Contract_repr.contract (* `Temporary *)
| Empty_implicit_contract of Signature.Public_key_hash.t (* `Temporary *)
| Empty_transaction of Contract_repr.t (* `Temporary *)
| Inconsistent_hash of Signature.Public_key.t * Signature.Public_key_hash.t * Signature.Public_key_hash.t (* `Permanent *)
| Inconsistent_public_key of Signature.Public_key.t * Signature.Public_key.t (* `Permanent *)
| Failure of string (* `Permanent *)
| Previously_revealed_key of Contract_repr.t (* `Permanent *)
| Unrevealed_manager_key of Contract_repr.t (* `Permanent *)
let () =
register_error_kind
`Permanent
~id:"contract.unspendable_contract"
~title:"Unspendable contract"
~description:"An operation tried to spend tokens from an unspendable contract"
~pp:(fun ppf c ->
Format.fprintf ppf "The tokens of contract %a can only be spent by its script"
Contract_repr.pp c)
Data_encoding.(obj1 (req "contract" Contract_repr.encoding))
(function Unspendable_contract c -> Some c | _ -> None)
(fun c -> Unspendable_contract c) ;
register_error_kind
`Temporary
~id:"contract.balance_too_low"
~title:"Balance too low"
~description:"An operation tried to spend more tokens than the contract has"
~pp:(fun ppf (c, b, a) ->
Format.fprintf ppf "Balance of contract %a too low (%a) to spend %a"
Contract_repr.pp c Tez_repr.pp b Tez_repr.pp a)
Data_encoding.(obj3
(req "contract" Contract_repr.encoding)
(req "balance" Tez_repr.encoding)
(req "amount" Tez_repr.encoding))
(function Balance_too_low (c, b, a) -> Some (c, b, a) | _ -> None)
(fun (c, b, a) -> Balance_too_low (c, b, a)) ;
register_error_kind
`Temporary
~id:"contract.counter_in_the_future"
~title:"Invalid counter (not yet reached) in a manager operation"
~description:"An operation assumed a contract counter in the future"
~pp:(fun ppf (contract, exp, found) ->
Format.fprintf ppf
"Counter %s not yet reached for contract %a (expected %s)"
(Z.to_string found)
Contract_repr.pp contract
(Z.to_string exp))
Data_encoding.
(obj3
(req "contract" Contract_repr.encoding)
(req "expected" z)
(req "found" z))
(function Counter_in_the_future (c, x, y) -> Some (c, x, y) | _ -> None)
(fun (c, x, y) -> Counter_in_the_future (c, x, y)) ;
register_error_kind
`Branch
~id:"contract.counter_in_the_past"
~title:"Invalid counter (already used) in a manager operation"
~description:"An operation assumed a contract counter in the past"
~pp:(fun ppf (contract, exp, found) ->
Format.fprintf ppf
"Counter %s already used for contract %a (expected %s)"
(Z.to_string found)
Contract_repr.pp contract
(Z.to_string exp))
Data_encoding.
(obj3
(req "contract" Contract_repr.encoding)
(req "expected" z)
(req "found" z))
(function Counter_in_the_past (c, x, y) -> Some (c, x, y) | _ -> None)
(fun (c, x, y) -> Counter_in_the_past (c, x, y)) ;
register_error_kind
`Temporary
~id:"contract.non_existing_contract"
~title:"Non existing contract"
~description:"A contract handle is not present in the context \
(either it never was or it has been destroyed)"
~pp:(fun ppf contract ->
Format.fprintf ppf "Contract %a does not exist"
Contract_repr.pp contract)
Data_encoding.(obj1 (req "contract" Contract_repr.encoding))
(function Non_existing_contract c -> Some c | _ -> None)
(fun c -> Non_existing_contract c) ;
register_error_kind
`Permanent
~id:"contract.manager.inconsistent_hash"
~title:"Inconsistent public key hash"
~description:"A revealed manager public key is inconsistent with the announced hash"
~pp:(fun ppf (k, eh, ph) ->
Format.fprintf ppf "The hash of the manager public key %s is not %a as announced but %a"
(Signature.Public_key.to_b58check k)
Signature.Public_key_hash.pp ph
Signature.Public_key_hash.pp eh)
Data_encoding.(obj3
(req "public_key" Signature.Public_key.encoding)
(req "expected_hash" Signature.Public_key_hash.encoding)
(req "provided_hash" Signature.Public_key_hash.encoding))
(function Inconsistent_hash (k, eh, ph) -> Some (k, eh, ph) | _ -> None)
(fun (k, eh, ph) -> Inconsistent_hash (k, eh, ph)) ;
register_error_kind
`Permanent
~id:"contract.manager.inconsistent_public_key"
~title:"Inconsistent public key"
~description:"A provided manager public key is different with the public key stored in the contract"
~pp:(fun ppf (eh, ph) ->
Format.fprintf ppf "Expected manager public key %s but %s was provided"
(Signature.Public_key.to_b58check ph)
(Signature.Public_key.to_b58check eh))
Data_encoding.(obj2
(req "public_key" Signature.Public_key.encoding)
(req "expected_public_key" Signature.Public_key.encoding))
(function Inconsistent_public_key (eh, ph) -> Some (eh, ph) | _ -> None)
(fun (eh, ph) -> Inconsistent_public_key (eh, ph)) ;
register_error_kind
`Permanent
~id:"contract.failure"
~title:"Contract storage failure"
~description:"Unexpected contract storage error"
~pp:(fun ppf s -> Format.fprintf ppf "Contract_storage.Failure %S" s)
Data_encoding.(obj1 (req "message" string))
(function Failure s -> Some s | _ -> None)
(fun s -> Failure s) ;
register_error_kind
`Branch
~id:"contract.unrevealed_key"
~title:"Manager operation precedes key revelation"
~description:
"One tried to apply a manager operation \
without revealing the manager public key"
~pp:(fun ppf s ->
Format.fprintf ppf "Unrevealed manager key for contract %a."
Contract_repr.pp s)
Data_encoding.(obj1 (req "contract" Contract_repr.encoding))
(function Unrevealed_manager_key s -> Some s | _ -> None)
(fun s -> Unrevealed_manager_key s) ;
register_error_kind
`Branch
~id:"contract.previously_revealed_key"
~title:"Manager operation already revealed"
~description:
"One tried to revealed twice a manager public key"
~pp:(fun ppf s ->
Format.fprintf ppf "Previously revealed manager key for contract %a."
Contract_repr.pp s)
Data_encoding.(obj1 (req "contract" Contract_repr.encoding))
(function Previously_revealed_key s -> Some s | _ -> None)
(fun s -> Previously_revealed_key s) ;
register_error_kind
`Branch
~id:"implicit.empty_implicit_contract"
~title:"Empty implicit contract"
~description:"No manager operations are allowed on an empty implicit contract."
~pp:(fun ppf implicit ->
Format.fprintf ppf
"Empty implicit contract (%a)"
Signature.Public_key_hash.pp implicit)
Data_encoding.(obj1 (req "implicit" Signature.Public_key_hash.encoding))
(function Empty_implicit_contract c -> Some c | _ -> None)
(fun c -> Empty_implicit_contract c) ;
register_error_kind
`Branch
~id:"contract.empty_transaction"
~title:"Empty transaction"
~description:"Forbidden to credit 0ꜩ to a contract without code."
~pp:(fun ppf contract ->
Format.fprintf ppf
"Transaction of 0ꜩ towards a contract without code are forbidden (%a)."
Contract_repr.pp contract)
Data_encoding.(obj1 (req "contract" Contract_repr.encoding))
(function Empty_transaction c -> Some c | _ -> None)
(fun c -> Empty_transaction c)
let failwith msg = fail (Failure msg)
type big_map_diff_item =
| Update of {
big_map : Z.t;
diff_key : Script_repr.expr;
diff_key_hash : Script_expr_hash.t;
diff_value : Script_repr.expr option;
}
| Clear of Z.t
| Copy of Z.t * Z.t
| Alloc of {
big_map : Z.t;
key_type : Script_repr.expr;
value_type : Script_repr.expr;
}
type big_map_diff = big_map_diff_item list
let big_map_diff_item_encoding =
let open Data_encoding in
union
[ case (Tag 0) ~title:"update"
(obj5
(req "action" (constant "update"))
(req "big_map" z)
(req "key_hash" Script_expr_hash.encoding)
(req "key" Script_repr.expr_encoding)
(opt "value" Script_repr.expr_encoding))
(function
| Update { big_map ; diff_key_hash ; diff_key ; diff_value } ->
Some ((), big_map, diff_key_hash, diff_key, diff_value)
| _ -> None )
(fun ((), big_map, diff_key_hash, diff_key, diff_value) ->
Update { big_map ; diff_key_hash ; diff_key ; diff_value }) ;
case (Tag 1) ~title:"remove"
(obj2
(req "action" (constant "remove"))
(req "big_map" z))
(function
| Clear big_map ->
Some ((), big_map)
| _ -> None )
(fun ((), big_map) ->
Clear big_map) ;
case (Tag 2) ~title:"copy"
(obj3
(req "action" (constant "copy"))
(req "source_big_map" z)
(req "destination_big_map" z))
(function
| Copy (src, dst) ->
Some ((), src, dst)
| _ -> None )
(fun ((), src, dst) ->
Copy (src, dst)) ;
case (Tag 3) ~title:"alloc"
(obj4
(req "action" (constant "alloc"))
(req "big_map" z)
(req "key_type" Script_repr.expr_encoding)
(req "value_type" Script_repr.expr_encoding))
(function
| Alloc { big_map ; key_type ; value_type } ->
Some ((), big_map, key_type, value_type)
| _ -> None )
(fun ((), big_map, key_type, value_type) ->
Alloc { big_map ; key_type ; value_type }) ]
let big_map_diff_encoding =
let open Data_encoding in
def "contract.big_map_diff" @@
list big_map_diff_item_encoding
let big_map_key_cost = 65
let big_map_cost = 33
let update_script_big_map c = function
| None -> return (c, Z.zero)
| Some diff ->
fold_left_s (fun (c, total) -> function
| Clear id ->
Storage.Big_map.Total_bytes.get c id >>=? fun size ->
Storage.Big_map.remove_rec c id >>= fun c ->
if Compare.Z.(id < Z.zero) then
return (c, total)
else
return (c, Z.sub (Z.sub total size) (Z.of_int big_map_cost))
| Copy (from, to_) ->
Storage.Big_map.copy c ~from ~to_ >>=? fun c ->
if Compare.Z.(to_ < Z.zero) then
return (c, total)
else
Storage.Big_map.Total_bytes.get c from >>=? fun size ->
return (c, Z.add (Z.add total size) (Z.of_int big_map_cost))
| Alloc { big_map ; key_type ; value_type } ->
Storage.Big_map.Total_bytes.init c big_map Z.zero >>=? fun c ->
(* Annotations are erased to allow sharing on
[Copy]. The types from the contract code are used,
these ones are only used to make sure they are
compatible during transmissions between contracts,
and only need to be compatible, annotations
nonwhistanding. *)
let key_type = Micheline.strip_locations (Script_repr.strip_annotations (Micheline.root key_type)) in
let value_type = Micheline.strip_locations (Script_repr.strip_annotations (Micheline.root value_type)) in
Storage.Big_map.Key_type.init c big_map key_type >>=? fun c ->
Storage.Big_map.Value_type.init c big_map value_type >>=? fun c ->
if Compare.Z.(big_map < Z.zero) then
return (c, total)
else
return (c, Z.add total (Z.of_int big_map_cost))
| Update { big_map ; diff_key_hash ; diff_value = None } ->
Storage.Big_map.Contents.remove (c, big_map) diff_key_hash
>>=? fun (c, freed, existed) ->
let freed = if existed then freed + big_map_key_cost else freed in
Storage.Big_map.Total_bytes.get c big_map >>=? fun size ->
Storage.Big_map.Total_bytes.set c big_map (Z.sub size (Z.of_int freed)) >>=? fun c ->
if Compare.Z.(big_map < Z.zero) then
return (c, total)
else
return (c, Z.sub total (Z.of_int freed))
| Update { big_map ; diff_key_hash ; diff_value = Some v } ->
Storage.Big_map.Contents.init_set (c, big_map) diff_key_hash v
>>=? fun (c, size_diff, existed) ->
let size_diff = if existed then size_diff else size_diff + big_map_key_cost in
Storage.Big_map.Total_bytes.get c big_map >>=? fun size ->
Storage.Big_map.Total_bytes.set c big_map (Z.add size (Z.of_int size_diff)) >>=? fun c ->
if Compare.Z.(big_map < Z.zero) then
return (c, total)
else
return (c, Z.add total (Z.of_int size_diff)))
(c, Z.zero) diff
let create_base c
?(prepaid_bootstrap_storage=false) (* Free space for bootstrap contracts *)
contract
~balance ~manager ~delegate ?script () =
begin match Contract_repr.is_implicit contract with
| None -> return c
| Some _ ->
Storage.Contract.Global_counter.get c >>=? fun counter ->
Storage.Contract.Counter.init c contract counter
end >>=? fun c ->
Storage.Contract.Balance.init c contract balance >>=? fun c ->
begin match manager with
| Some manager ->
Storage.Contract.Manager.init c contract (Manager_repr.Hash manager)
| None -> return c
end >>=? fun c ->
begin
match delegate with
| None -> return c
| Some delegate ->
Delegate_storage.init c contract delegate
end >>=? fun c ->
match script with
| Some ({ Script_repr.code ; storage }, big_map_diff) ->
Storage.Contract.Code.init c contract code >>=? fun (c, code_size) ->
Storage.Contract.Storage.init c contract storage >>=? fun (c, storage_size) ->
update_script_big_map c big_map_diff >>=? fun (c, big_map_size) ->
let total_size = Z.add (Z.add (Z.of_int code_size) (Z.of_int storage_size)) big_map_size in
assert Compare.Z.(total_size >= Z.zero) ;
let prepaid_bootstrap_storage =
if prepaid_bootstrap_storage then
total_size
else
Z.zero
in
Storage.Contract.Paid_storage_space.init c contract prepaid_bootstrap_storage >>=? fun c ->
Storage.Contract.Used_storage_space.init c contract total_size
| None ->
return c
let originate c ?prepaid_bootstrap_storage contract
~balance ~script ~delegate =
create_base c ?prepaid_bootstrap_storage contract ~balance
~manager:None ~delegate ~script ()
let create_implicit c manager ~balance =
create_base c (Contract_repr.implicit_contract manager)
~balance ~manager:(Some manager) ?script:None ~delegate:None ()
let delete c contract =
match Contract_repr.is_implicit contract with
| None ->
(* For non implicit contract Big_map should be cleared *)
failwith "Non implicit contracts cannot be removed"
| Some _ ->
Delegate_storage.remove c contract >>=? fun c ->
Storage.Contract.Balance.delete c contract >>=? fun c ->
Storage.Contract.Manager.delete c contract >>=? fun c ->
Storage.Contract.Counter.delete c contract >>=? fun c ->
Storage.Contract.Code.remove c contract >>=? fun (c, _, _) ->
Storage.Contract.Storage.remove c contract >>=? fun (c, _, _) ->
Storage.Contract.Paid_storage_space.remove c contract >>= fun c ->
Storage.Contract.Used_storage_space.remove c contract >>= fun c ->
return c
let allocated c contract =
Storage.Contract.Balance.get_option c contract >>=? function
| None -> return_false
| Some _ -> return_true
let exists c contract =
match Contract_repr.is_implicit contract with
| Some _ -> return_true
| None -> allocated c contract
let must_exist c contract =
exists c contract >>=? function
| true -> return_unit
| false -> fail (Non_existing_contract contract)
let must_be_allocated c contract =
allocated c contract >>=? function
| true -> return_unit
| false ->
match Contract_repr.is_implicit contract with
| Some pkh -> fail (Empty_implicit_contract pkh)
| None -> fail (Non_existing_contract contract)
let list c = Storage.Contract.list c
let fresh_contract_from_current_nonce c =
Lwt.return (Raw_context.increment_origination_nonce c) >>=? fun (c, nonce) ->
return (c, Contract_repr.originated_contract nonce)
let originated_from_current_nonce ~since: ctxt_since ~until: ctxt_until =
Lwt.return (Raw_context.origination_nonce ctxt_since) >>=? fun since ->
Lwt.return (Raw_context.origination_nonce ctxt_until) >>=? fun until ->
filter_map_s
(fun contract -> exists ctxt_until contract >>=? function
| true -> return_some contract
| false -> return_none)
(Contract_repr.originated_contracts ~since ~until)
let check_counter_increment c manager counter =
let contract = Contract_repr.implicit_contract manager in
Storage.Contract.Counter.get c contract >>=? fun contract_counter ->
let expected = Z.succ contract_counter in
if Compare.Z.(expected = counter)
then return_unit
else if Compare.Z.(expected > counter) then
fail (Counter_in_the_past (contract, expected, counter))
else
fail (Counter_in_the_future (contract, expected, counter))
let increment_counter c manager =
let contract = Contract_repr.implicit_contract manager in
Storage.Contract.Global_counter.get c >>=? fun global_counter ->
Storage.Contract.Global_counter.set c (Z.succ global_counter) >>=? fun c ->
Storage.Contract.Counter.get c contract >>=? fun contract_counter ->
Storage.Contract.Counter.set c contract (Z.succ contract_counter)
let get_script_code c contract =
Storage.Contract.Code.get_option c contract
let get_script c contract =
Storage.Contract.Code.get_option c contract >>=? fun (c, code) ->
Storage.Contract.Storage.get_option c contract >>=? fun (c, storage) ->
match code, storage with
| None, None -> return (c, None)
| Some code, Some storage -> return (c, Some { Script_repr.code ; storage })
| None, Some _ | Some _, None -> failwith "get_script"
let get_storage ctxt contract =
Storage.Contract.Storage.get_option ctxt contract >>=? function
| (ctxt, None) -> return (ctxt, None)
| (ctxt, Some storage) ->
Lwt.return (Script_repr.force_decode storage) >>=? fun (storage, cost) ->
Lwt.return (Raw_context.consume_gas ctxt cost) >>=? fun ctxt ->
return (ctxt, Some storage)
let get_counter c manager =
let contract = Contract_repr.implicit_contract manager in
Storage.Contract.Counter.get_option c contract >>=? function
| None -> begin
match Contract_repr.is_implicit contract with
| Some _ -> Storage.Contract.Global_counter.get c
| None -> failwith "get_counter"
end
| Some v -> return v
let get_manager_004 c contract =
Storage.Contract.Manager.get_option c contract >>=? function
| None -> begin
match Contract_repr.is_implicit contract with
| Some manager -> return manager
| None -> failwith "get_manager"
end
| Some (Manager_repr.Hash v) -> return v
| Some (Manager_repr.Public_key v) -> return (Signature.Public_key.hash v)
let get_manager_key c manager =
let contract = Contract_repr.implicit_contract manager in
Storage.Contract.Manager.get_option c contract >>=? function
| None -> failwith "get_manager_key"
| Some (Manager_repr.Hash _) -> fail (Unrevealed_manager_key contract)
| Some (Manager_repr.Public_key v) -> return v
let is_manager_key_revealed c manager =
let contract = Contract_repr.implicit_contract manager in
Storage.Contract.Manager.get_option c contract >>=? function
| None -> return_false
| Some (Manager_repr.Hash _) -> return_false
| Some (Manager_repr.Public_key _) -> return_true
let reveal_manager_key c manager public_key =
let contract = Contract_repr.implicit_contract manager in
Storage.Contract.Manager.get c contract >>=? function
| Public_key _ -> fail (Previously_revealed_key contract)
| Hash v ->
let actual_hash = Signature.Public_key.hash public_key in
if (Signature.Public_key_hash.equal actual_hash v) then
let v = (Manager_repr.Public_key public_key) in
Storage.Contract.Manager.set c contract v >>=? fun c ->
return c
else fail (Inconsistent_hash (public_key,v,actual_hash))
let get_balance c contract =
Storage.Contract.Balance.get_option c contract >>=? function
| None -> begin
match Contract_repr.is_implicit contract with
| Some _ -> return Tez_repr.zero
| None -> failwith "get_balance"
end
| Some v -> return v
let update_script_storage c contract storage big_map_diff =
let storage = Script_repr.lazy_expr storage in
update_script_big_map c big_map_diff >>=? fun (c, big_map_size_diff) ->
Storage.Contract.Storage.set c contract storage >>=? fun (c, size_diff) ->
Storage.Contract.Used_storage_space.get c contract >>=? fun previous_size ->
let new_size = Z.add previous_size (Z.add big_map_size_diff (Z.of_int size_diff)) in
Storage.Contract.Used_storage_space.set c contract new_size
let spend c contract amount =
Storage.Contract.Balance.get c contract >>=? fun balance ->
match Tez_repr.(balance -? amount) with
| Error _ ->
fail (Balance_too_low (contract, balance, amount))
| Ok new_balance ->
Storage.Contract.Balance.set c contract new_balance >>=? fun c ->
Roll_storage.Contract.remove_amount c contract amount >>=? fun c ->
if Tez_repr.(new_balance > Tez_repr.zero) then
return c
else match Contract_repr.is_implicit contract with
| None -> return c (* Never delete originated contracts *)
| Some pkh ->
Delegate_storage.get c contract >>=? function
| Some pkh' ->
(* Don't delete "delegate" contract *)
assert (Signature.Public_key_hash.equal pkh pkh') ;
return c
| None ->
(* Delete empty implicit contract *)
delete c contract
let credit c contract amount =
begin
if Tez_repr.(amount <> Tez_repr.zero) then
return c
else
Storage.Contract.Code.mem c contract >>=? fun (c, target_has_code) ->
fail_unless target_has_code (Empty_transaction contract) >>=? fun () ->
return c
end >>=? fun c ->
Storage.Contract.Balance.get_option c contract >>=? function
| None -> begin
match Contract_repr.is_implicit contract with
| None -> fail (Non_existing_contract contract)
| Some manager ->
create_implicit c manager ~balance:amount
end
| Some balance ->
Lwt.return Tez_repr.(amount +? balance) >>=? fun balance ->
Storage.Contract.Balance.set c contract balance >>=? fun c ->
Roll_storage.Contract.add_amount c contract amount
let init c =
Storage.Contract.Global_counter.init c Z.zero
let used_storage_space c contract =
Storage.Contract.Used_storage_space.get_option c contract >>=? function
| None -> return Z.zero
| Some fees -> return fees
let paid_storage_space c contract =
Storage.Contract.Paid_storage_space.get_option c contract >>=? function
| None -> return Z.zero
| Some paid_space -> return paid_space
let set_paid_storage_space_and_return_fees_to_pay c contract new_storage_space =
Storage.Contract.Paid_storage_space.get c contract >>=? fun already_paid_space ->
if Compare.Z.(already_paid_space >= new_storage_space) then
return (Z.zero, c)
else
let to_pay = Z.sub new_storage_space already_paid_space in
Storage.Contract.Paid_storage_space.set c contract new_storage_space >>=? fun c ->
return (to_pay, c)
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
secp256k1.ml | include Tezos_crypto.Secp256k1
module Public_key_hash = struct
include Tezos_crypto.Secp256k1.Public_key_hash
module Set = struct
include Stdlib.Set.Make (Tezos_crypto.Secp256k1.Public_key_hash)
let encoding =
Data_encoding.conv
elements
(fun l -> List.fold_left (fun m x -> add x m) empty l)
Data_encoding.(list Tezos_crypto.Secp256k1.Public_key_hash.encoding)
end
module Map = struct
include Stdlib.Map.Make (Tezos_crypto.Secp256k1.Public_key_hash)
let encoding arg_encoding =
Data_encoding.conv
bindings
(fun l -> List.fold_left (fun m (k, v) -> add k v m) empty l)
Data_encoding.(
list
(tup2 Tezos_crypto.Secp256k1.Public_key_hash.encoding arg_encoding))
end
module Table = struct
include Stdlib.Hashtbl.MakeSeeded (struct
include Tezos_crypto.Secp256k1.Public_key_hash
let hash = Stdlib.Hashtbl.seeded_hash
end)
let encoding arg_encoding =
Data_encoding.conv
(fun h -> fold (fun k v l -> (k, v) :: l) h [])
(fun l ->
let h = create (List.length l) in
List.iter (fun (k, v) -> add h k v) l ;
h)
Data_encoding.(
list
(tup2 Tezos_crypto.Secp256k1.Public_key_hash.encoding arg_encoding))
end
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2020 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
script_typed_ir.ml | open Alpha_context
open Script_int
(* ---- Auxiliary types -----------------------------------------------------*)
type var_annot = [ `Var_annot of string ]
type type_annot = [ `Type_annot of string ]
type field_annot = [ `Field_annot of string ]
type annot = [ var_annot | type_annot | field_annot ]
type 'ty comparable_ty =
| Int_key : type_annot option -> (z num) comparable_ty
| Nat_key : type_annot option -> (n num) comparable_ty
| String_key : type_annot option -> string comparable_ty
| Bytes_key : type_annot option -> MBytes.t comparable_ty
| Mutez_key : type_annot option -> Tez.t comparable_ty
| Bool_key : type_annot option -> bool comparable_ty
| Key_hash_key : type_annot option -> public_key_hash comparable_ty
| Timestamp_key : type_annot option -> Script_timestamp.t comparable_ty
| Address_key : type_annot option -> Contract.t comparable_ty
module type Boxed_set = sig
type elt
module OPS : S.SET with type elt = elt
val boxed : OPS.t
val size : int
end
type 'elt set = (module Boxed_set with type elt = 'elt)
module type Boxed_map = sig
type key
type value
val key_ty : key comparable_ty
module OPS : S.MAP with type key = key
val boxed : value OPS.t * int
end
type ('key, 'value) map = (module Boxed_map with type key = 'key and type value = 'value)
type ('arg, 'storage) script =
{ code : (('arg, 'storage) pair, (packed_internal_operation list, 'storage) pair) lambda ;
arg_type : 'arg ty ;
storage : 'storage ;
storage_type : 'storage ty }
and ('a, 'b) pair = 'a * 'b
and ('a, 'b) union = L of 'a | R of 'b
and end_of_stack = unit
and ('arg, 'ret) lambda =
Lam of ('arg * end_of_stack, 'ret * end_of_stack) descr * Script.expr
and 'arg typed_contract =
'arg ty * Contract.t
and 'ty ty =
| Unit_t : type_annot option -> unit ty
| Int_t : type_annot option -> z num ty
| Nat_t : type_annot option -> n num ty
| Signature_t : type_annot option -> signature ty
| String_t : type_annot option -> string ty
| Bytes_t : type_annot option -> MBytes.t ty
| Mutez_t : type_annot option -> Tez.t ty
| Key_hash_t : type_annot option -> public_key_hash ty
| Key_t : type_annot option -> public_key ty
| Timestamp_t : type_annot option -> Script_timestamp.t ty
| Address_t : type_annot option -> Contract.t ty
| Bool_t : type_annot option -> bool ty
| Pair_t :
('a ty * field_annot option * var_annot option) *
('b ty * field_annot option * var_annot option) *
type_annot option -> ('a, 'b) pair ty
| Union_t : ('a ty * field_annot option) * ('b ty * field_annot option) * type_annot option -> ('a, 'b) union ty
| Lambda_t : 'arg ty * 'ret ty * type_annot option -> ('arg, 'ret) lambda ty
| Option_t : ('v ty * field_annot option) * field_annot option * type_annot option -> 'v option ty
| List_t : 'v ty * type_annot option -> 'v list ty
| Set_t : 'v comparable_ty * type_annot option -> 'v set ty
| Map_t : 'k comparable_ty * 'v ty * type_annot option -> ('k, 'v) map ty
| Big_map_t : 'k comparable_ty * 'v ty * type_annot option -> ('k, 'v) big_map ty
| Contract_t : 'arg ty * type_annot option -> 'arg typed_contract ty
| Operation_t : type_annot option -> packed_internal_operation ty
and 'ty stack_ty =
| Item_t : 'ty ty * 'rest stack_ty * var_annot option -> ('ty * 'rest) stack_ty
| Empty_t : end_of_stack stack_ty
and ('key, 'value) big_map = { diff : ('key, 'value option) map ;
key_type : 'key ty ;
value_type : 'value ty }
(* ---- Instructions --------------------------------------------------------*)
(* The low-level, typed instructions, as a GADT whose parameters
encode the typing rules. The left parameter is the typed shape of
the stack before the instruction, the right one the shape
after. Any program whose construction is accepted by OCaml's
type-checker is guaranteed to be type-safe. Overloadings of the
concrete syntax are already resolved in this representation, either
by using different constructors or type witness parameters. *)
and ('bef, 'aft) instr =
(* stack ops *)
| Drop :
(_ * 'rest, 'rest) instr
| Dup :
('top * 'rest, 'top * ('top * 'rest)) instr
| Swap :
('tip * ('top * 'rest), 'top * ('tip * 'rest)) instr
| Const : 'ty ->
('rest, ('ty * 'rest)) instr
(* pairs *)
| Cons_pair :
(('car * ('cdr * 'rest)), (('car, 'cdr) pair * 'rest)) instr
| Car :
(('car, _) pair * 'rest, 'car * 'rest) instr
| Cdr :
((_, 'cdr) pair * 'rest, 'cdr * 'rest) instr
(* options *)
| Cons_some :
('v * 'rest, 'v option * 'rest) instr
| Cons_none : 'a ty ->
('rest, 'a option * 'rest) instr
| If_none : ('bef, 'aft) descr * ('a * 'bef, 'aft) descr ->
('a option * 'bef, 'aft) instr
(* unions *)
| Left :
('l * 'rest, (('l, 'r) union * 'rest)) instr
| Right :
('r * 'rest, (('l, 'r) union * 'rest)) instr
| If_left : ('l * 'bef, 'aft) descr * ('r * 'bef, 'aft) descr ->
(('l, 'r) union * 'bef, 'aft) instr
(* lists *)
| Cons_list :
('a * ('a list * 'rest), ('a list * 'rest)) instr
| Nil :
('rest, ('a list * 'rest)) instr
| If_cons : ('a * ('a list * 'bef), 'aft) descr * ('bef, 'aft) descr ->
('a list * 'bef, 'aft) instr
| List_map : ('a * 'rest, 'b * 'rest) descr ->
('a list * 'rest, 'b list * 'rest) instr
| List_iter : ('a * 'rest, 'rest) descr ->
('a list * 'rest, 'rest) instr
| List_size : ('a list * 'rest, n num * 'rest) instr
(* sets *)
| Empty_set : 'a comparable_ty ->
('rest, 'a set * 'rest) instr
| Set_iter : ('a * 'rest, 'rest) descr ->
('a set * 'rest, 'rest) instr
| Set_mem :
('elt * ('elt set * 'rest), bool * 'rest) instr
| Set_update :
('elt * (bool * ('elt set * 'rest)), 'elt set * 'rest) instr
| Set_size : ('a set * 'rest, n num * 'rest) instr
(* maps *)
| Empty_map : 'a comparable_ty * 'v ty ->
('rest, ('a, 'v) map * 'rest) instr
| Map_map : (('a * 'v) * 'rest, 'r * 'rest) descr ->
(('a, 'v) map * 'rest, ('a, 'r) map * 'rest) instr
| Map_iter : (('a * 'v) * 'rest, 'rest) descr ->
(('a, 'v) map * 'rest, 'rest) instr
| Map_mem :
('a * (('a, 'v) map * 'rest), bool * 'rest) instr
| Map_get :
('a * (('a, 'v) map * 'rest), 'v option * 'rest) instr
| Map_update :
('a * ('v option * (('a, 'v) map * 'rest)), ('a, 'v) map * 'rest) instr
| Map_size : (('a, 'b) map * 'rest, n num * 'rest) instr
(* big maps *)
| Big_map_mem :
('a * (('a, 'v) big_map * 'rest), bool * 'rest) instr
| Big_map_get :
('a * (('a, 'v) big_map * 'rest), 'v option * 'rest) instr
| Big_map_update :
('key * ('value option * (('key, 'value) big_map * 'rest)), ('key, 'value) big_map * 'rest) instr
(* string operations *)
| Concat_string :
(string list * 'rest, string * 'rest) instr
| Concat_string_pair :
(string * (string * 'rest), string * 'rest) instr
| Slice_string :
(n num * (n num * (string * 'rest)), string option * 'rest) instr
| String_size :
(string * 'rest, n num * 'rest) instr
(* bytes operations *)
| Concat_bytes :
(MBytes.t list * 'rest, MBytes.t * 'rest) instr
| Concat_bytes_pair :
(MBytes.t * (MBytes.t * 'rest), MBytes.t * 'rest) instr
| Slice_bytes :
(n num * (n num * (MBytes.t * 'rest)), MBytes.t option * 'rest) instr
| Bytes_size :
(MBytes.t * 'rest, n num * 'rest) instr
(* timestamp operations *)
| Add_seconds_to_timestamp :
(z num * (Script_timestamp.t * 'rest),
Script_timestamp.t * 'rest) instr
| Add_timestamp_to_seconds :
(Script_timestamp.t * (z num * 'rest),
Script_timestamp.t * 'rest) instr
| Sub_timestamp_seconds :
(Script_timestamp.t * (z num * 'rest),
Script_timestamp.t * 'rest) instr
| Diff_timestamps :
(Script_timestamp.t * (Script_timestamp.t * 'rest),
z num * 'rest) instr
(* currency operations *)
(* TODO: we can either just have conversions to/from integers and
do all operations on integers, or we need more operations on
Tez. Also Sub_tez should return Tez.t option (if negative) and *)
| Add_tez :
(Tez.t * (Tez.t * 'rest), Tez.t * 'rest) instr
| Sub_tez :
(Tez.t * (Tez.t * 'rest), Tez.t * 'rest) instr
| Mul_teznat :
(Tez.t * (n num * 'rest), Tez.t * 'rest) instr
| Mul_nattez :
(n num * (Tez.t * 'rest), Tez.t * 'rest) instr
| Ediv_teznat :
(Tez.t * (n num * 'rest), ((Tez.t, Tez.t) pair) option * 'rest) instr
| Ediv_tez :
(Tez.t * (Tez.t * 'rest), ((n num, Tez.t) pair) option * 'rest) instr
(* boolean operations *)
| Or :
(bool * (bool * 'rest), bool * 'rest) instr
| And :
(bool * (bool * 'rest), bool * 'rest) instr
| Xor :
(bool * (bool * 'rest), bool * 'rest) instr
| Not :
(bool * 'rest, bool * 'rest) instr
(* integer operations *)
| Is_nat :
(z num * 'rest, n num option * 'rest) instr
| Neg_nat :
(n num * 'rest, z num * 'rest) instr
| Neg_int :
(z num * 'rest, z num * 'rest) instr
| Abs_int :
(z num * 'rest, n num * 'rest) instr
| Int_nat :
(n num * 'rest, z num * 'rest) instr
| Add_intint :
(z num * (z num * 'rest), z num * 'rest) instr
| Add_intnat :
(z num * (n num * 'rest), z num * 'rest) instr
| Add_natint :
(n num * (z num * 'rest), z num * 'rest) instr
| Add_natnat :
(n num * (n num * 'rest), n num * 'rest) instr
| Sub_int :
('s num * ('t num * 'rest), z num * 'rest) instr
| Mul_intint :
(z num * (z num * 'rest), z num * 'rest) instr
| Mul_intnat :
(z num * (n num * 'rest), z num * 'rest) instr
| Mul_natint :
(n num * (z num * 'rest), z num * 'rest) instr
| Mul_natnat :
(n num * (n num * 'rest), n num * 'rest) instr
| Ediv_intint :
(z num * (z num * 'rest), ((z num, n num) pair) option * 'rest) instr
| Ediv_intnat :
(z num * (n num * 'rest), ((z num, n num) pair) option * 'rest) instr
| Ediv_natint :
(n num * (z num * 'rest), ((z num, n num) pair) option * 'rest) instr
| Ediv_natnat :
(n num * (n num * 'rest), ((n num, n num) pair) option * 'rest) instr
| Lsl_nat :
(n num * (n num * 'rest), n num * 'rest) instr
| Lsr_nat :
(n num * (n num * 'rest), n num * 'rest) instr
| Or_nat :
(n num * (n num * 'rest), n num * 'rest) instr
| And_nat :
(n num * (n num * 'rest), n num * 'rest) instr
| And_int_nat :
(z num * (n num * 'rest), n num * 'rest) instr
| Xor_nat :
(n num * (n num * 'rest), n num * 'rest) instr
| Not_nat :
(n num * 'rest, z num * 'rest) instr
| Not_int :
(z num * 'rest, z num * 'rest) instr
(* control *)
| Seq : ('bef, 'trans) descr * ('trans, 'aft) descr ->
('bef, 'aft) instr
| If : ('bef, 'aft) descr * ('bef, 'aft) descr ->
(bool * 'bef, 'aft) instr
| Loop : ('rest, bool * 'rest) descr ->
(bool * 'rest, 'rest) instr
| Loop_left : ('a * 'rest, ('a, 'b) union * 'rest) descr ->
(('a, 'b) union * 'rest, 'b * 'rest) instr
| Dip : ('bef, 'aft) descr ->
('top * 'bef, 'top * 'aft) instr
| Exec :
('arg * (('arg, 'ret) lambda * 'rest), 'ret * 'rest) instr
| Lambda : ('arg, 'ret) lambda ->
('rest, ('arg, 'ret) lambda * 'rest) instr
| Failwith :
'a ty -> ('a * 'rest, 'aft) instr
| Nop :
('rest, 'rest) instr
(* comparison *)
| Compare : 'a comparable_ty ->
('a * ('a * 'rest), z num * 'rest) instr
(* comparators *)
| Eq :
(z num * 'rest, bool * 'rest) instr
| Neq :
(z num * 'rest, bool * 'rest) instr
| Lt :
(z num * 'rest, bool * 'rest) instr
| Gt :
(z num * 'rest, bool * 'rest) instr
| Le :
(z num * 'rest, bool * 'rest) instr
| Ge :
(z num * 'rest, bool * 'rest) instr
(* protocol *)
| Address :
(_ typed_contract * 'rest, Contract.t * 'rest) instr
| Contract : 'p ty ->
(Contract.t * 'rest, 'p typed_contract option * 'rest) instr
| Transfer_tokens :
('arg * (Tez.t * ('arg typed_contract * 'rest)), packed_internal_operation * 'rest) instr
| Create_account :
(public_key_hash * (public_key_hash option * (bool * (Tez.t * 'rest))),
packed_internal_operation * (Contract.t * 'rest)) instr
| Implicit_account :
(public_key_hash * 'rest, unit typed_contract * 'rest) instr
| Create_contract : 'g ty * 'p ty * ('p * 'g, packed_internal_operation list * 'g) lambda ->
(public_key_hash * (public_key_hash option * (bool * (bool * (Tez.t * ('g * 'rest))))),
packed_internal_operation * (Contract.t * 'rest)) instr
| Set_delegate :
(public_key_hash option * 'rest, packed_internal_operation * 'rest) instr
| Now :
('rest, Script_timestamp.t * 'rest) instr
| Balance :
('rest, Tez.t * 'rest) instr
| Check_signature :
(public_key * (signature * (MBytes.t * 'rest)), bool * 'rest) instr
| Hash_key :
(public_key * 'rest, public_key_hash * 'rest) instr
| Pack : 'a ty ->
('a * 'rest, MBytes.t * 'rest) instr
| Unpack : 'a ty ->
(MBytes.t * 'rest, 'a option * 'rest) instr
| Blake2b :
(MBytes.t * 'rest, MBytes.t * 'rest) instr
| Sha256 :
(MBytes.t * 'rest, MBytes.t * 'rest) instr
| Sha512 :
(MBytes.t * 'rest, MBytes.t * 'rest) instr
| Steps_to_quota : (* TODO: check that it always returns a nat *)
('rest, n num * 'rest) instr
| Source :
('rest, Contract.t * 'rest) instr
| Sender :
('rest, Contract.t * 'rest) instr
| Self : 'p ty ->
('rest, 'p typed_contract * 'rest) instr
| Amount :
('rest, Tez.t * 'rest) instr
and ('bef, 'aft) descr =
{ loc : Script.location ;
bef : 'bef stack_ty ;
aft : 'aft stack_ty ;
instr : ('bef, 'aft) instr }
type ex_big_map = Ex_bm : ('key, 'value) big_map -> ex_big_map
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
reason_toolchain_conf.ml |
open Reason_omp
include Ast_411
module From_current = Convert(OCaml_current)(OCaml_411)
module To_current = Convert(OCaml_411)(OCaml_current)
module type Toolchain = sig
(* Parsing *)
val core_type_with_comments: Lexing.lexbuf -> (Parsetree.core_type * Reason_comment.t list)
val implementation_with_comments: Lexing.lexbuf -> (Parsetree.structure * Reason_comment.t list)
val interface_with_comments: Lexing.lexbuf -> (Parsetree.signature * Reason_comment.t list)
val core_type: Lexing.lexbuf -> Parsetree.core_type
val implementation: Lexing.lexbuf -> Parsetree.structure
val interface: Lexing.lexbuf -> Parsetree.signature
val toplevel_phrase: Lexing.lexbuf -> Parsetree.toplevel_phrase
val use_file: Lexing.lexbuf -> Parsetree.toplevel_phrase list
(* Printing *)
val print_interface_with_comments: Format.formatter -> (Parsetree.signature * Reason_comment.t list) -> unit
val print_implementation_with_comments: Format.formatter -> (Parsetree.structure * Reason_comment.t list) -> unit
end
module type Toolchain_spec = sig
val safeguard_parsing: Lexing.lexbuf ->
(unit -> ('a * Reason_comment.t list)) -> ('a * Reason_comment.t list)
type token
type invalid_docstrings
module Lexer : sig
type t
val init: ?insert_completion_ident:Lexing.position ->
Lexing.lexbuf -> t
val get_comments: t -> invalid_docstrings -> (string * Location.t) list
end
val core_type: Lexer.t -> Parsetree.core_type * invalid_docstrings
val implementation: Lexer.t -> Parsetree.structure * invalid_docstrings
val interface: Lexer.t -> Parsetree.signature * invalid_docstrings
val toplevel_phrase: Lexer.t -> Parsetree.toplevel_phrase * invalid_docstrings
val use_file: Lexer.t -> Parsetree.toplevel_phrase list * invalid_docstrings
val format_interface_with_comments: (Parsetree.signature * Reason_comment.t list) -> Format.formatter -> unit
val format_implementation_with_comments: (Parsetree.structure * Reason_comment.t list) -> Format.formatter -> unit
end
let insert_completion_ident : Lexing.position option ref = ref None
| |
vmm_asn.mli | (* (c) 2017, 2018 Hannes Mehnert, all rights reserved *)
open Vmm_core
(** ASN.1 encoding of resources and configuration *)
(** {1 Object Identifier} *)
(** OID in the Mirage namespace (enterprise arc 1.3.6.1.4.1.49836.42) *)
val oid : Asn.OID.t
val wire_to_cstruct : Vmm_commands.wire -> Cstruct.t
val wire_of_cstruct : Cstruct.t -> (Vmm_commands.wire, [> `Msg of string ]) result
val of_cert_extension :
Cstruct.t -> (Vmm_commands.version * Vmm_commands.t, [> `Msg of string ]) result
val to_cert_extension : Vmm_commands.t -> Cstruct.t
val unikernels_to_cstruct : Unikernel.config Vmm_trie.t -> Cstruct.t
val unikernels_of_cstruct : Cstruct.t -> (Unikernel.config Vmm_trie.t, [> `Msg of string ]) result
| (* (c) 2017, 2018 Hannes Mehnert, all rights reserved *)
|
equal_ui.c |
#include "fmpz_mpoly.h"
int fmpz_mpoly_equal_ui(const fmpz_mpoly_t A,
ulong c, const fmpz_mpoly_ctx_t ctx)
{
slong N;
if (c == 0)
return A->length == 0;
if (A->length != 1)
return 0;
N = mpoly_words_per_exp(A->bits, ctx->minfo);
if (!mpoly_monomial_is_zero(A->exps + N*0, N))
return 0;
return fmpz_equal_ui(A->coeffs + 0, c);
}
| /*
Copyright (C) 2016 William Hart
Copyright (C) 2018 Daniel Schultz
This file is part of FLINT.
FLINT is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <https://www.gnu.org/licenses/>.
*/ |
open_in_classes.ml | (* TEST
* expect
*)
module M = struct
type t = int
let x = 42
end
;;
[%%expect{|
module M : sig type t = int val x : int end
|}]
class c =
let open M in
object
method f : t = x
end
;;
[%%expect{|
class c : object method f : M.t end
|}]
class type ct =
let open M in
object
method f : t
end
;;
[%%expect{|
class type ct = object method f : M.t end
|}]
| (* TEST
* expect
*) |
dune |
(test
(name main)
(package xen-gnt-unix)
(libraries xen-gnt xen-gnt-unix))
| |
js-low-priority.ml | (* Relatively low priority Jane Street indentation bugs. *)
(* js-args *)
(* uncommon *)
let x =
try x with a -> b
| c -> d
let x =
try x
with a -> b
| c -> d
(* js-comment *)
let mk_cont_parser cont_parse = (); fun _state str ~max_pos ~pos ->
let len = max_pos - pos + 1 in
cont_parse ~pos ~len str
(* sexp parser is sensitive to
absent newlines at the end of files. *)
(* It would be nice if a partially completed ocamldoc code fragment inside a
comment had the closing delimiter "]}" indented nicely before the comment is
closed. (This has to be the last comment in the file, to be partial.) *)
(* Maybe add:
{[
val state : t -> [ `Unstarted | `Running | `Stopped ]
]}
| (* Relatively low priority Jane Street indentation bugs. *)
|
invariants.c |
#include "acb_elliptic.h"
#include "acb_modular.h"
void
acb_elliptic_invariants(acb_t g2, acb_t g3, const acb_t tau, slong prec)
{
acb_struct t[2];
acb_init(t);
acb_init(t + 1);
acb_modular_eisenstein(t, tau, 2, prec);
acb_mul_ui(g2, t, 60, prec);
acb_mul_ui(g3, t + 1, 140, prec);
acb_clear(t);
acb_clear(t + 1);
}
| /*
Copyright (C) 2017 Fredrik Johansson
This file is part of Arb.
Arb is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <http://www.gnu.org/licenses/>.
*/ |
sf_context_settings_c.h |
#ifndef _CSF_CONTEXTSETTINGS_INC
#define _CSF_CONTEXTSETTINGS_INC
#include <SFML/Window/Window.h>
void SfContextSettings_val(sfContextSettings *settings, value ml_settings);
value Val_sfContextSettings(sfContextSettings *settings);
#endif // _CSF_CONTEXTSETTINGS_INC
| |
clb_partial_orderings.h |
#ifndef CLB_PARTIAL_ORDERINGS
#define CLB_PARTIAL_ORDERINGS
#include <clb_defines.h>
/*---------------------------------------------------------------------*/
/* Data type declarations */
/*---------------------------------------------------------------------*/
/* Possible results of partial ordering comparisons */
typedef enum
{
to_unknown = 0,
to_uncomparable = 1,
to_equal = 2,
to_greater = 3,
to_lesser = 4,
to_notgteq, /* For caching partial LPO results */
to_notleeq
}CompareResult;
/*---------------------------------------------------------------------*/
/* Exported Functions and Variables */
/*---------------------------------------------------------------------*/
extern char* POCompareSymbol[];
/* Translating standard UNIX total Quasi-Ordering comparions into
CompareResult: */
#define Q_TO_PART(res) (((res)<0) ? to_lesser:\
(((res)>0) ? to_greater:to_equal))
static inline CompareResult POInverseRelation(CompareResult
relation);
/*---------------------------------------------------------------------*/
/* Implementations as inline functions */
/*---------------------------------------------------------------------*/
/*-----------------------------------------------------------------------
//
// Function: POInverseRelation()
//
// Given a comparison relation, return the inverse relation.
//
// Global Variables: -
//
// Side Effects : -
//
/----------------------------------------------------------------------*/
static inline CompareResult POInverseRelation(CompareResult
relation)
{
CompareResult res = relation;
switch(relation)
{
case to_equal:
case to_uncomparable:
break;
case to_greater:
res = to_lesser;
break;
case to_lesser:
res = to_greater;
break;
case to_notgteq:
res = to_notleeq;
break;
case to_notleeq:
res = to_notgteq;
break;
default:
assert(false);
break;
}
return res;
}
#endif
/*---------------------------------------------------------------------*/
/* End of File */
/*---------------------------------------------------------------------*/
| /*-----------------------------------------------------------------------
File : clb_partial_orderings.h
Author: Stephan Schulz
Contents
Functions and datatypes useful in dealing with partial orderings.
Copyright 1998, 1999 by the author.
This code is released under the GNU General Public Licence and
the GNU Lesser General Public License.
See the file COPYING in the main E directory for details..
Run "eprover -h" for contact information.
Changes
<1> Wed Jun 16 22:37:09 MET DST 1999
New
-----------------------------------------------------------------------*/ |
t-compose_mod_brent_kung_precomp_preinv.c |
#undef ulong
#define ulong ulongxx/* interferes with system includes */
#include <stdlib.h>
#include <stdio.h>
#undef ulong
#include <gmp.h>
#define ulong mp_limb_t
#include "flint.h"
#include "nmod_poly.h"
#include "ulong_extras.h"
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("compose_mod_brent_kung_precomp_preinv....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c, cinv, d, e;
nmod_mat_t B;
mp_limb_t m = n_randtest_prime(state, 0);
nmod_poly_init(a, m);
nmod_poly_init(b, m);
nmod_poly_init(c, m);
nmod_poly_init(cinv, m);
nmod_poly_init(d, m);
nmod_poly_init(e, m);
nmod_poly_randtest(a, state, 1+n_randint(state, 20));
nmod_poly_randtest(b, state, 1+n_randint(state, 20));
nmod_poly_randtest_not_zero(c, state, 1+n_randint(state, 20));
nmod_poly_rem(a, a, c);
nmod_poly_reverse(cinv, c, c->length);
nmod_poly_inv_series(cinv, cinv, c->length);
nmod_mat_init (B, n_sqrt (c->length-1)+1, c->length-1, m);
nmod_poly_precompute_matrix (B, b, c, cinv);
nmod_poly_compose_mod_brent_kung_precomp_preinv(d, a, B, c, cinv);
nmod_poly_compose(e, a, b);
nmod_poly_rem(e, e, c);
if (!nmod_poly_equal(d, e))
{
flint_printf("FAIL (composition):\n");
nmod_poly_print(a); flint_printf("\n");
nmod_poly_print(b); flint_printf("\n");
nmod_poly_print(c); flint_printf("\n");
nmod_poly_print(cinv); flint_printf("\n");
nmod_poly_print(d); flint_printf("\n");
nmod_poly_print(e); flint_printf("\n");
fflush(stdout);
flint_abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_mat_clear (B);
nmod_poly_clear(c);
nmod_poly_clear(cinv);
nmod_poly_clear(d);
nmod_poly_clear(e);
}
/* Test aliasing of res and a */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c, cinv, d;
nmod_mat_t B;
mp_limb_t m = n_randtest_prime(state, 0);
nmod_poly_init(a, m);
nmod_poly_init(b, m);
nmod_poly_init(c, m);
nmod_poly_init(cinv, m);
nmod_poly_init(d, m);
nmod_poly_randtest(a, state, 1+n_randint(state, 20));
nmod_poly_randtest(b, state, 1+n_randint(state, 20));
nmod_poly_randtest_not_zero(c, state, 1+n_randint(state, 20));
nmod_poly_rem(a, a, c);
nmod_poly_reverse(cinv, c, c->length);
nmod_poly_inv_series(cinv, cinv, c->length);
nmod_mat_init (B, n_sqrt (c->length-1)+1, c->length-1, m);
nmod_poly_precompute_matrix (B, b, c, cinv);
nmod_poly_compose_mod_brent_kung_precomp_preinv(d, a, B, c, cinv);
nmod_poly_compose_mod_brent_kung_precomp_preinv(a, a, B, c, cinv);
if (!nmod_poly_equal(d, a))
{
flint_printf("FAIL (aliasing a):\n");
nmod_poly_print(a); flint_printf("\n");
nmod_poly_print(b); flint_printf("\n");
nmod_poly_print(c); flint_printf("\n");
nmod_poly_print(cinv); flint_printf("\n");
nmod_poly_print(d); flint_printf("\n");
fflush(stdout);
flint_abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_mat_clear (B);
nmod_poly_clear(c);
nmod_poly_clear(cinv);
nmod_poly_clear(d);
}
/* Test aliasing of res and c */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c, cinv, d;
nmod_mat_t B;
mp_limb_t m = n_randtest_prime(state, 0);
nmod_poly_init(a, m);
nmod_poly_init(b, m);
nmod_poly_init(c, m);
nmod_poly_init(cinv, m);
nmod_poly_init(d, m);
nmod_poly_randtest(a, state, 1+n_randint(state, 20));
nmod_poly_randtest(b, state, 1+n_randint(state, 20));
nmod_poly_randtest_not_zero(c, state, 1+n_randint(state, 20));
nmod_poly_rem(a, a, c);
nmod_poly_reverse(cinv, c, c->length);
nmod_poly_inv_series(cinv, cinv, c->length);
nmod_mat_init (B, n_sqrt (c->length-1)+1, c->length-1, m);
nmod_poly_precompute_matrix (B, b, c, cinv);
nmod_poly_compose_mod_brent_kung_precomp_preinv(d, a, B, c, cinv);
nmod_poly_compose_mod_brent_kung_precomp_preinv(c, a, B, c, cinv);
if (!nmod_poly_equal(d, c))
{
flint_printf("FAIL (aliasing c)\n");
nmod_poly_print(a); flint_printf("\n");
nmod_poly_print(b); flint_printf("\n");
nmod_poly_print(c); flint_printf("\n");
nmod_poly_print(cinv); flint_printf("\n");
nmod_poly_print(d); flint_printf("\n");
fflush(stdout);
flint_abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_mat_clear (B);
nmod_poly_clear(c);
nmod_poly_clear(cinv);
nmod_poly_clear(d);
}
/* Test aliasing of res and cinv */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c, cinv, d;
nmod_mat_t B;
mp_limb_t m = n_randtest_prime(state, 0);
nmod_poly_init(a, m);
nmod_poly_init(b, m);
nmod_poly_init(c, m);
nmod_poly_init(cinv, m);
nmod_poly_init(d, m);
nmod_poly_randtest(a, state, 1+n_randint(state, 20));
nmod_poly_randtest(b, state, 1+n_randint(state, 20));
nmod_poly_randtest_not_zero(c, state, 1+n_randint(state, 20));
nmod_poly_rem(a, a, c);
nmod_poly_reverse(cinv, c, c->length);
nmod_poly_inv_series(cinv, cinv, c->length);
nmod_mat_init (B, n_sqrt (c->length-1)+1, c->length-1, m);
nmod_poly_precompute_matrix (B, b, c, cinv);
nmod_poly_compose_mod_brent_kung_precomp_preinv(d, a, B, c, cinv);
nmod_poly_compose_mod_brent_kung_precomp_preinv(cinv, a, B, c, cinv);
if (!nmod_poly_equal(d, cinv))
{
flint_printf("FAIL (aliasing cinv)\n");
nmod_poly_print(a); flint_printf("\n");
nmod_poly_print(b); flint_printf("\n");
nmod_poly_print(c); flint_printf("\n");
nmod_poly_print(cinv); flint_printf("\n");
nmod_poly_print(d); flint_printf("\n");
fflush(stdout);
flint_abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_mat_clear (B);
nmod_poly_clear(c);
nmod_poly_clear(cinv);
nmod_poly_clear(d);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
| /*
Copyright (C) 2011 Fredrik Johansson
Copyright (C) 2013 Martin Lee
This file is part of FLINT.
FLINT is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <https://www.gnu.org/licenses/>.
*/ |
polynomial_primes.h | #pragma once
namespace polynomial {
#define NUM_SMALL_PRIMES 11
const unsigned g_small_primes[NUM_SMALL_PRIMES] = {
13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53
};
#if 0
#define NUM_BIG_PRIMES 77
const unsigned g_big_primes[NUM_BIG_PRIMES] = {
16777259, 16777289, 16777291, 16777331, 16777333, 16777337, 16777381,
16777421, 16777441, 16777447, 16777469, 16777499, 16777507, 16777531,
16777571, 16777577, 16777597, 16777601, 16777619, 16777633, 16777639,
16777643, 16777669, 16777679, 16777681, 16777699, 16777711, 16777721,
16777723, 16777729, 16777751, 16777777, 16777781, 16777807, 16777811,
16777823, 16777829, 16777837, 16777853, 16777903, 16777907, 16777949,
16777967, 16777973, 16777987, 16777991, 16778009, 16778023, 16778071,
16778077, 16778089, 16778123, 16778129, 16778137, 16778147, 16778173,
16778227, 16778231, 16778291, 16778309, 16778357, 16778383, 16778401,
16778413, 16778429, 16778441, 16778449, 16778453, 16778497, 16778521,
16778537, 16778543, 16778549, 16778561, 16778603, 16778623, 16778627
};
#else
#define NUM_BIG_PRIMES 231
const unsigned g_big_primes[NUM_BIG_PRIMES] = {
39103, 39107, 39113, 39119, 39133, 39139, 39157, 39161, 39163, 39181, 39191,
39199, 39209, 39217, 39227, 39229, 39233, 39239, 39241, 39251, 39293, 39301,
39313, 39317, 39323, 39341, 39343, 39359, 39367, 39371, 39373, 39383, 39397,
39409, 39419, 39439, 39443, 39451, 39461, 39499, 39503, 39509, 39511, 39521,
39541, 39551, 39563, 39569, 39581, 39607, 39619, 39623, 39631, 39659, 39667,
39671, 39679, 39703, 39709, 39719, 39727, 39733, 39749, 39761, 39769, 39779,
39791, 39799, 39821, 39827, 39829, 39839, 39841, 39847, 39857, 39863, 39869,
39877, 39883, 39887, 39901, 39929, 39937, 39953, 39971, 39979, 39983, 39989,
40009, 40013, 40031, 40037, 40039, 40063, 40087, 40093, 40099, 40111, 40123,
40127, 40129, 40151, 40153, 40163, 40169, 40177, 40189, 40193, 40213, 40231,
40237, 40241, 40253, 40277, 40283, 40289, 40343, 40351, 40357, 40361, 40387,
40423, 40427, 40429, 40433, 40459, 40471, 40483, 40487, 40493, 40499, 40507,
40519, 40529, 40531, 40543, 40559, 40577, 40583, 40591, 40597, 40609, 40627,
40637, 40639, 40693, 40697, 40699, 40709, 40739, 40751, 40759, 40763, 40771,
40787, 40801, 40813, 40819, 40823, 40829, 40841, 40847, 40849, 40853, 40867,
40879, 40883, 40897, 40903, 40927, 40933, 40939, 40949, 40961, 40973, 40993,
41011, 41017, 41023, 41039, 41047, 41051, 41057, 41077, 41081, 41113, 41117,
41131, 41141, 41143, 41149, 41161, 41177, 41179, 41183, 41189, 41201, 41203,
41213, 41221, 41227, 41231, 41233, 41243, 41257, 41263, 41269, 41281, 41299,
41333, 41341, 41351, 41357, 41381, 41387, 41389, 41399, 41411, 41413, 41443,
41453, 41467, 41479, 41491, 41507, 41513, 41519, 41521, 41539, 41543, 41549
};
#endif
};
| /*++
Copyright (c) 2012 Microsoft Corporation
Module Name:
polynomial_primes.h
Abstract:
Some prime numbers for modular computations.
Author:
Leonardo (leonardo) 2011-12-21
Notes:
--*/ |
tezos_daemon.ml |
open Internal_pervasives
type args =
| Baker : string -> args
| Endorser : string -> args
| Accuser : args
type t =
{ node: Tezos_node.t
; client: Tezos_client.t
; exec: Tezos_executable.t
; args: args
; name_tag: string option }
let of_node ?name_tag node args ~exec ~client =
{node; exec; client; args; name_tag}
let baker_of_node ?name_tag nod ~key = of_node nod ?name_tag (Baker key)
let endorser_of_node ?name_tag nod ~key = of_node nod ?name_tag (Endorser key)
let accuser_of_node ?name_tag nod = of_node ?name_tag nod Accuser
let arg_to_string = function
| Baker k -> sprintf "baker-%s" k
| Endorser k -> sprintf "endorser-%s" k
| Accuser -> "accuser"
let to_script state (t : t) =
let base_dir = Tezos_client.base_dir ~state t.client in
let call t args =
Tezos_executable.call state t.exec
~path:
( base_dir
// sprintf "exec-%s-%d%s" (arg_to_string t.args)
t.node.Tezos_node.rpc_port
(Option.value_map t.name_tag ~default:"" ~f:(sprintf "-%s")) )
args in
match t.args with
| Baker key ->
let node_path = Tezos_node.data_dir state t.node in
call t
[ "--endpoint"
; sprintf "http://localhost:%d" t.node.Tezos_node.rpc_port
; "--base-dir"; base_dir; "run"; "with"; "local"; "node"; node_path
; key ]
| Endorser key ->
call t
[ "--endpoint"
; sprintf "http://localhost:%d" t.node.Tezos_node.rpc_port
; "--base-dir"; base_dir; "run"; key ]
| Accuser ->
call t
[ "--endpoint"
; sprintf "http://localhost:%d" t.node.Tezos_node.rpc_port
; "--base-dir"; base_dir; "run"; "--preserved-levels"; "10" ]
let process state (t : t) =
Running_processes.Process.genspio
(sprintf "%s-for-%s%s" (arg_to_string t.args) t.node.Tezos_node.id
(Option.value_map t.name_tag ~default:"" ~f:(sprintf "-%s")))
(to_script state t)
| |
dune |
(library
(name lib))
| |
dune |
(library
(name a)
(public_name a)
(modules a)
)
(library
(name mytool_plugin_b)
(public_name mytool-plugin-b)
(modules mytool_plugin_b)
(libraries a mytool)
)
(library
(name mytool)
(public_name mytool)
(modules register)
)
(executable
(name main)
(modules main)
(public_name mytool)
(package mytool)
(libraries mytool findlib.dynload threads)
)
(rule (copy main.ml main_with_a.ml))
(rule (copy main.ml main_modes_byte.ml))
(executable
(name main_with_a)
(modules main_with_a)
(public_name mytool_with_a)
(package mytool)
(libraries mytool findlib.dynload a threads)
)
(executable
(name main_modes_byte)
(modules main_modes_byte)
(public_name mytool_modes_byte)
(package mytool)
(libraries mytool findlib.dynload threads)
(modes byte)
)
(executable
(name main_auto)
(modules main_auto)
(public_name mytool_auto)
(package mytool)
(libraries mytool findlib.dynload findlib threads)
)
(library
(name c_thread)
(public_name c_thread)
(modules c_thread)
(libraries threads mytool)
)
| |
fftw3.ml |
open Bigarray
module type Sig = sig
type float_elt
(** Precision of float numbers. *)
type complex_elt
(** Precision of complex numbers. *)
val float : (float, float_elt) Bigarray.kind
val complex : (Complex.t, complex_elt) Bigarray.kind
type 'a plan (* Immutable FFTW plan. *)
type c2c
type r2c
type c2r
type r2r
type dir = Forward | Backward
type measure =
| Estimate
| Measure
| Patient
| Exhaustive
type r2r_kind =
| R2HC | HC2R | DHT
| REDFT00 | REDFT01 | REDFT10 | REDFT11
| RODFT00 | RODFT01 | RODFT10 | RODFT11
exception Failure of string
val exec : 'a plan -> unit
module Guru : sig
end
module Genarray :
sig
external create: ('a, 'b) kind -> 'c layout -> int array
-> ('a, 'b, 'c) Bigarray.Genarray.t
= "fftw3_ocaml_ba_create"
type 'l complex_array = (Complex.t, complex_elt, 'l) Bigarray.Genarray.t
type 'l float_array = (float, float_elt, 'l) Bigarray.Genarray.t
type coord = int array
val dft : dir ->
?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l complex_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l complex_array
-> c2c plan
val r2c : ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l float_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l complex_array
-> r2c plan
val c2r : ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l complex_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l float_array
-> c2r plan
val r2r : r2r_kind array ->
?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l float_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l float_array
-> r2r plan
end
module Array1 :
sig
val create: ('a, 'b) kind -> 'c layout -> int -> ('a, 'b, 'c) Array1.t
val of_array : ('a, 'b) kind -> 'c layout -> 'a array -> ('a, 'b, 'c) Array1.t
type 'l complex_array = (Complex.t, complex_elt, 'l) Array1.t
type 'l float_array = (float, float_elt, 'l) Array1.t
val dft : dir -> ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi:int list ->
?ni:int -> ?ofsi:int -> ?inci:int -> 'l complex_array ->
?howmanyo:int list ->
?no:int -> ?ofso:int -> ?inco:int -> 'l complex_array
-> c2c plan
val r2c : ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: int list ->
?ni: int -> ?ofsi: int -> ?inci: int -> 'l float_array ->
?howmanyo: int list ->
?no: int -> ?ofso: int -> ?inco: int -> 'l complex_array
-> r2c plan
val c2r : ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: int list ->
?ni: int -> ?ofsi: int -> ?inci: int -> 'l complex_array ->
?howmanyo: int list ->
?no: int -> ?ofso: int -> ?inco: int -> 'l float_array
-> c2r plan
val r2r : r2r_kind -> ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi:int list ->
?ni:int -> ?ofsi:int -> ?inci:int -> 'l float_array ->
?howmanyo:int list ->
?no:int -> ?ofso:int -> ?inco:int -> 'l float_array
-> r2r plan
end
module Array2 :
sig
val create: ('a, 'b) kind -> 'c layout -> int -> int -> ('a, 'b, 'c) Array2.t
type 'l complex_array = (Complex.t, complex_elt, 'l) Array2.t
type 'l float_array = (float, float_elt, 'l) Array2.t
type coord = int * int
val dft : dir ->
?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l complex_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l complex_array
-> c2c plan
val r2c : ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l float_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l complex_array
-> r2c plan
val c2r : ?meas:measure ->
?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l complex_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l float_array
-> c2r plan
val r2r : r2r_kind * r2r_kind -> ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l float_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l float_array
-> r2r plan
end
module Array3 :
sig
val create: ('a, 'b) kind -> 'c layout -> int -> int -> int
-> ('a, 'b, 'c) Array3.t
type 'l complex_array = (Complex.t, complex_elt, 'l) Array3.t
type 'l float_array = (float, float_elt, 'l) Array3.t
type coord = int * int * int
val dft : dir ->
?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n: int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l complex_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l complex_array
-> c2c plan
val r2c : ?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l float_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l complex_array
-> r2c plan
val c2r : ?meas:measure ->
?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l complex_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l float_array
-> c2r plan
val r2r : r2r_kind * r2r_kind * r2r_kind ->
?meas:measure ->
?destroy_input:bool -> ?unaligned:bool ->
?howmany_n:int array ->
?howmanyi: coord list ->
?ni: coord -> ?ofsi: coord -> ?inci: coord -> 'l float_array ->
?howmanyo: coord list ->
?no: coord -> ?ofso: coord -> ?inco: coord -> 'l float_array
-> r2r plan
end
end
(** {2 Precision dependent modules}
***********************************************************************)
module D = Fftw3D
module S = Fftw3S
module Wisdom =
struct
external to_file : string -> unit = "fftw3_ocaml_export_wisdom_to_file"
external to_string : unit -> string = "fftw3_ocaml_export_wisdom_to_string"
external export : unit -> unit = "fftw3_ocaml_export_wisdom"
let export write =
Callback.register "fftw3_wisdom_export" (write: char -> unit);
export() (* FIXME: is the callback for each char way really efficient??
It is probably better to export strings to ocaml and have
an output function -- like Unix.output *)
external from_system : unit -> unit = "fftw3_ocaml_import_system_wisdom"
external from_file : string -> unit = "fftw3_ocaml_import_wisdom_from_file"
external from_string : string -> unit
= "fftw3_ocaml_import_wisdom_from_string"
external import : unit -> unit = "fftw3_ocaml_import_wisdom"
let import read =
let read_char () = try Char.code(read()) with End_of_file -> -1 (* EOF *) in
Callback.register "fftw3_wisdom_import" (read_char: unit -> int);
import()
external forget : unit -> unit = "fftw3_ocaml_forget_wisdom"
end
| (* File: fftw3.ml
Objective Caml interface for FFTW.
Copyright (C) 2005-
Christophe Troestler <Christophe.Troestler@umons.ac.be>
WWW: https://math.umons.ac.be/anum/software/
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License
version 2.1 as published by the Free Software Foundation, with the
special exception on linking described in file LICENSE.
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the file
LICENSE for more details.
*) |
storage_description.mli | (** Typed description of the key-value context. *)
type 'key t
(** Trivial display of the key-value context layout. *)
val pp : Format.formatter -> 'key t -> unit
(** Export an RPC hierarchy for querying the context. There is one service
by possible path in the context. Services for "directory" are able to
aggregate in one JSON object the whole subtree. *)
val build_directory : 'key t -> 'key RPC_directory.t
(** Create a empty context description,
keys will be registered by side effects. *)
val create : unit -> 'key t
(** Register a single key accessor at a given path. *)
val register_value :
'key t ->
get:('key -> 'a option tzresult Lwt.t) ->
'a Data_encoding.t ->
unit
(** Return a description for a prefixed fragment of the given context.
All keys registered in the subcontext will be shared by the external
context *)
val register_named_subcontext : 'key t -> string list -> 'key t
(** Description of an index as a sequence of `RPC_arg.t`. *)
type (_, _, _) args =
| One : {
rpc_arg : 'a RPC_arg.t;
encoding : 'a Data_encoding.t;
compare : 'a -> 'a -> int;
}
-> ('key, 'a, 'key * 'a) args
| Pair :
('key, 'a, 'inter_key) args * ('inter_key, 'b, 'sub_key) args
-> ('key, 'a * 'b, 'sub_key) args
(** Return a description for a indexed sub-context.
All keys registered in the subcontext will be shared by the external
context. One should provide a function to list all the registered
index in the context. *)
val register_indexed_subcontext :
'key t ->
list:('key -> 'arg list tzresult Lwt.t) ->
('key, 'arg, 'sub_key) args ->
'sub_key t
(** Helpers for manipulating and defining indexes. *)
val pack : ('key, 'a, 'sub_key) args -> 'key -> 'a -> 'sub_key
val unpack : ('key, 'a, 'sub_key) args -> 'sub_key -> 'key * 'a
module type INDEX = sig
type t
val path_length : int
val to_path : t -> string list -> string list
val of_path : string list -> t option
val rpc_arg : t RPC_arg.t
val encoding : t Data_encoding.t
val compare : t -> t -> int
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
irmin_fs.mli |
(** Disk persistence. *)
module Conf : sig
open Irmin.Backend.Conf
val spec : Spec.t
module Key : sig
val root : string key
end
end
val config : string -> Irmin.config
(** [config root] is the a configuration with the key {!Irmin.Config.root} set
to [root]. **)
module type IO = sig
(** {1 File-system abstractions} *)
type path = string
(** The type for paths. *)
(** {2 Read operations} *)
val rec_files : path -> string list Lwt.t
(** [rec_files dir] is the list of files recursively present in [dir] and all
of its sub-directories. Return filenames prefixed by [dir]. *)
val file_exists : path -> bool Lwt.t
(** [file_exist f] is true if [f] exists. *)
val read_file : path -> string option Lwt.t
(** Read the contents of a file using mmap. *)
(** {2 Write Operations} *)
val mkdir : path -> unit Lwt.t
(** Create a directory. *)
type lock
(** The type for file locks. *)
val lock_file : path -> lock
(** [lock_file f] is the lock associated to the file [f]. *)
val write_file : ?temp_dir:path -> ?lock:lock -> path -> string -> unit Lwt.t
(** Atomic writes. *)
val test_and_set_file :
?temp_dir:string ->
lock:lock ->
path ->
test:string option ->
set:string option ->
bool Lwt.t
(** Test and set. *)
val remove_file : ?lock:lock -> path -> unit Lwt.t
(** Remove a file or directory (even if non-empty). *)
end
module Append_only (IO : IO) : Irmin.Append_only.Maker
module Atomic_write (IO : IO) : Irmin.Atomic_write.Maker
module Maker (IO : IO) : Irmin.Maker
module KV (IO : IO) : Irmin.KV_maker
(** {2 Advanced configuration} *)
module type Config = sig
(** Same as [Config] but gives more control on the file hierarchy. *)
val dir : string -> string
(** [dir root] is the sub-directory to look for the keys. *)
val file_of_key : string -> string
(** Convert a key to a filename. *)
val key_of_file : string -> string
(** Convert a filename to a key. *)
end
module Append_only_ext (IO : IO) (C : Config) : Irmin.Append_only.Maker
module Atomic_write_ext (IO : IO) (C : Config) : Irmin.Atomic_write.Maker
module Maker_ext (IO : IO) (Obj : Config) (Ref : Config) : Irmin.Maker
(** {1 In-memory IO mocks} *)
module IO_mem : sig
include IO
val clear : unit -> unit Lwt.t
val set_listen_hook : unit -> unit
end
| (*
* Copyright (c) 2013-2021 Thomas Gazagnaire <thomas@gazagnaire.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*) |
test_pack_version_bump.mli |
val tests : unit Alcotest_lwt.test_case list
| |
script_timestamp_repr.mli | open Script_int_repr
type t
val of_int64 : int64 -> t
val compare : t -> t -> int
(* Convert a timestamp to a notation if possible *)
val to_notation : t -> string option
(* Convert a timestamp to a string representation of the seconds *)
val to_num_str : t -> string
(* Convert to a notation if possible, or num if not *)
val to_string : t -> string
val of_string : string -> t option
val diff : t -> t -> z num
val add_delta : t -> z num -> t
val sub_delta : t -> z num -> t
val to_zint : t -> Z.t
val of_zint : Z.t -> t
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
type_json.ml |
open Type_core
open Utils
type 'a encode_json = 'a Encode_json.t
type 'a decode_json = 'a Decode_json.t
module Encode = struct
let lexeme e l = ignore (Jsonm.encode e (`Lexeme l))
let unit e () =
lexeme e `Os;
lexeme e `Oe
let base64 e s =
let x = Base64.encode_exn s in
lexeme e `Os;
lexeme e (`Name "base64");
lexeme e (`String x);
lexeme e `Oe
let string e s = if is_valid_utf8 s then lexeme e (`String s) else base64 e s
let bytes e b =
let s = Bytes.unsafe_to_string b in
string e s
let char e c =
let s = String.make 1 c in
string e s
let float e f =
match classify_float f with
| FP_nan -> lexeme e (`String "nan")
| FP_infinite when Float.sign_bit f -> lexeme e (`String "-inf")
| FP_infinite -> lexeme e (`String "inf")
| _ -> lexeme e (`Float f)
let int e i = float e (float_of_int i)
let int32 e i = float e (Int32.to_float i)
let int64 e i = float e (Int64.to_float i)
let bool e b = lexeme e (`Bool b)
let list l e x =
lexeme e `As;
List.iter (l e) x;
lexeme e `Ae
let array l e x =
lexeme e `As;
Array.iter (l e) x;
lexeme e `Ae
let pair a b e (x, y) =
lexeme e `As;
a e x;
b e y;
lexeme e `Ae
let triple a b c e (x, y, z) =
lexeme e `As;
a e x;
b e y;
c e z;
lexeme e `Ae
let boxed_option o e = function
| None -> lexeme e `Null
| Some x ->
lexeme e `Os;
lexeme e (`Name "some");
o e x;
lexeme e `Oe
let rec t : type a. a t -> a encode_json = function
| Self s -> t s.self_fix
| Custom _ -> failwith "Unimplemented operation: encode_json"
| Map b -> map b
| Boxed x -> t x
| Attributes { attr_type = x; attrs } -> (
match Encode_json.find attrs with None -> t x | Some t -> t)
| Prim t -> prim t
| List l -> list (t l.v)
| Array a -> array (t a.v)
| Tuple t -> tuple t
| Option x -> boxed_option (t x)
| Record r -> record r
| Variant v -> variant v
| Var v -> raise (Unbound_type_variable v)
and tuple : type a. a tuple -> a encode_json = function
| Pair (x, y) -> pair (t x) (t y)
| Triple (x, y, z) -> triple (t x) (t y) (t z)
and map : type a b. (a, b) map -> b encode_json =
fun { x; g; _ } ->
let encode = t x in
fun e u -> encode e (g u)
and prim : type a. a prim -> a encode_json = function
| Unit -> unit
| Bool -> bool
| Char -> char
| Int -> int
| Int32 -> int32
| Int64 -> int64
| Float -> float
| String _ -> string
| Bytes _ -> bytes
and record : type a. a record -> a encode_json =
fun r ->
let fields = fields r in
fun e x ->
lexeme e `Os;
List.iter
(fun (Field f) ->
match (f.ftype, f.fget x) with
| Option _, None -> ()
| Option o, Some x ->
lexeme e (`Name f.fname);
t o e x
| List _, [] -> ()
| tx, x ->
lexeme e (`Name f.fname);
t tx e x)
fields;
lexeme e `Oe
and variant : type a. a variant -> a encode_json =
fun v e x -> case_v e (v.vget x)
and case_v : type a. a case_v encode_json =
fun e c ->
match c with
| CV0 c -> string e c.cname0
| CV1 (c, v) ->
lexeme e `Os;
lexeme e (`Name c.cname1);
t c.ctype1 e v;
lexeme e `Oe
let assoc : type a. a t -> (string * a) list encode_json =
fun a ->
let encode_a = t a in
fun e l ->
lexeme e `Os;
List.iter
(fun (k, v) ->
lexeme e (`Name k);
encode_a e v)
l;
lexeme e `Oe
end
module Decode = struct
let lexeme e =
match Json.decode e with
| `Lexeme e -> Ok e
| `Error e -> Error (`Msg (Fmt.to_to_string Jsonm.pp_error e))
| `End | `Await -> assert false
let ( >>= ) l f = match l with Error _ as e -> e | Ok l -> f l
let ( >|= ) l f = match l with Ok l -> Ok (f l) | Error _ as e -> e
let error e got expected =
let _, (l, c) = Jsonm.decoded_range e.d in
Error
(`Msg
(Fmt.str
"line %d, character %d:\nFound lexeme %a, but lexeme %s was expected"
l c Jsonm.pp_lexeme got expected))
let expect_lexeme e expected =
lexeme e >>= fun got ->
if expected = got then Ok ()
else error e got (Fmt.to_to_string Jsonm.pp_lexeme expected)
(* read all lexemes until the end of the next well-formed value *)
let value e =
let lexemes = ref [] in
let objs = ref 0 in
let arrs = ref 0 in
let rec aux () =
lexeme e >>= fun l ->
lexemes := l :: !lexemes;
let () =
match l with
| `Os -> incr objs
| `As -> incr arrs
| `Oe -> decr objs
| `Ae -> decr arrs
| `Name _ | `Null | `Bool _ | `String _ | `Float _ -> ()
in
if !objs > 0 || !arrs > 0 then aux () else Ok ()
in
aux () >|= fun () -> List.rev !lexemes
let unit e = expect_lexeme e `Os >>= fun () -> expect_lexeme e `Oe
let get_base64_value e =
match lexeme e with
| Ok (`Name "base64") -> (
match lexeme e with
| Ok (`String b) -> (
match expect_lexeme e `Oe with
| Ok () -> Ok (Base64.decode_exn b)
| Error e -> Error e)
| Ok l -> error e l "Bad base64 encoded character"
| Error e -> Error e)
| Ok l -> error e l "Invalid base64 object"
| Error e -> Error e
let string e =
lexeme e >>= function
| `String s -> Ok s
| `Os -> get_base64_value e
| l -> error e l "`String"
let bytes e =
lexeme e >>= function
| `String s -> Ok (Bytes.unsafe_of_string s)
| `Os -> (
match get_base64_value e with
| Ok s -> Ok (Bytes.unsafe_of_string s)
| Error e -> Error e)
| l -> error e l "`String"
let float e =
lexeme e >>= function
| `Float f -> Ok f
| `String "nan" -> Ok Float.nan
| `String "inf" -> Ok Float.infinity
| `String "-inf" -> Ok Float.neg_infinity
| l -> error e l "`Float"
let char e =
lexeme e >>= function
| `String s when String.length s = 1 -> Ok s.[0]
| `Os -> (
match get_base64_value e with Ok s -> Ok s.[0] | Error x -> Error x)
| l -> error e l "`String[0]"
let int32 e = float e >|= Int32.of_float
let int64 e = float e >|= Int64.of_float
let int e = float e >|= int_of_float
let bool e = lexeme e >>= function `Bool b -> Ok b | l -> error e l "`Bool"
let list l e =
expect_lexeme e `As >>= fun () ->
let rec aux acc =
lexeme e >>= function
| `Ae -> Ok (List.rev acc)
| lex ->
Json.rewind e lex;
l e >>= fun v -> aux (v :: acc)
in
aux []
let array l e = list l e >|= Array.of_list
let pair a b e =
expect_lexeme e `As >>= fun () ->
a e >>= fun x ->
b e >>= fun y ->
expect_lexeme e `Ae >|= fun () -> (x, y)
let triple a b c e =
expect_lexeme e `As >>= fun () ->
a e >>= fun x ->
b e >>= fun y ->
c e >>= fun z ->
expect_lexeme e `Ae >|= fun () -> (x, y, z)
let unboxed_option o e = o e >|= fun v -> Some v
let boxed_option o e =
lexeme e >>= function
| `Null -> Ok None
| `Os ->
expect_lexeme e (`Name "some") >>= fun () ->
o e >>= fun v ->
expect_lexeme e `Oe >|= fun () -> Some v
| l -> error e l "`Option-contents"
let rec t : type a. a t -> a decode_json = function
| Self s -> t s.self_fix
| Map b -> map b
| Prim t -> prim t
| Boxed x -> t x
| Attributes { attr_type = x; attrs } -> (
match Decode_json.find attrs with None -> t x | Some f -> f)
| List l -> list (t l.v)
| Array a -> array (t a.v)
| Tuple t -> tuple t
| Option x -> boxed_option (t x)
| Record r -> record r
| Variant v -> variant v
| Var v -> raise (Unbound_type_variable v)
| Custom _ -> failwith "Unimplemented operation: decode_json"
(* Some types need to be decoded differently when wrapped inside records,
since e.g. `k: None` is omitted and `k: Some v` is unboxed into `k: v`. *)
and inside_record_t : type a. a t -> a decode_json = function
| Option x -> unboxed_option (t x)
| ty -> t ty
and tuple : type a. a tuple -> a decode_json = function
| Pair (x, y) -> pair (t x) (t y)
| Triple (x, y, z) -> triple (t x) (t y) (t z)
and map : type a b. (a, b) map -> b decode_json =
fun { x; f; _ } ->
let decode = t x in
fun e -> decode e >|= f
and prim : type a. a prim -> a decode_json = function
| Unit -> unit
| Bool -> bool
| Char -> char
| Int -> int
| Int32 -> int32
| Int64 -> int64
| Float -> float
| String _ -> string
| Bytes _ -> bytes
and record : type a. a record -> a decode_json =
fun r ->
let (Fields (f, c)) = r.rfields in
fun e ->
expect_lexeme e `Os >>= fun () ->
let rec soup acc =
lexeme e >>= function
| `Name n -> value e >>= fun s -> soup ((n, s) :: acc)
| `Oe -> Ok acc
| l -> error e l "`Record-contents"
in
soup [] >>= fun soup ->
let rec aux :
type a b. (a, b) fields -> b -> (a, [ `Msg of string ]) result =
fun f c ->
match f with
| F0 -> Ok c
| F1 (h, f) -> (
let v =
try
let s = List.assoc h.fname soup in
let e = Json.decoder_of_lexemes s in
inside_record_t h.ftype e
with Not_found -> (
match h.ftype with
| Option _ -> Ok None
| List _ -> Ok []
| _ ->
Error
(`Msg (Fmt.str "missing value for %s.%s" r.rname h.fname)))
in
match v with Ok v -> aux f (c v) | Error _ as e -> e)
in
aux f c
and variant : type a. a variant -> a decode_json =
fun v e ->
lexeme e >>= function
| `String s -> case0 s v e
| `Os -> case1 v e
| l -> error e l "(`String | `Os)"
and case0 : type a. string -> a variant -> a decode_json =
fun s v _e ->
let rec aux i =
match v.vcases.(i) with
| C0 c when String.compare c.cname0 s = 0 -> Ok c.c0
| _ ->
if i < Array.length v.vcases then aux (i + 1)
else Error (`Msg "variant")
in
aux 0
and case1 : type a. a variant -> a decode_json =
fun v e ->
lexeme e >>= function
| `Name s ->
let rec aux i =
match v.vcases.(i) with
| C1 c when String.compare c.cname1 s = 0 -> t c.ctype1 e >|= c.c1
| _ ->
if i < Array.length v.vcases then aux (i + 1)
else Error (`Msg "variant")
in
aux 0 >>= fun c ->
expect_lexeme e `Oe >|= fun () -> c
| l -> error e l "`Name"
let assoc : type a. a t -> (string * a) list decode_json =
fun a ->
let decode_a = t a in
fun e ->
expect_lexeme e `Os >>= fun () ->
let rec aux acc =
lexeme e >>= function
| `Oe -> Ok acc
| `Name k -> decode_a e >>= fun v -> aux ((k, v) :: acc)
| l -> error e l "(`Name | `Oe)"
in
aux [] >|= List.rev
end
let encode = Encode.t
let decode = Decode.t
let decode_jsonm x d = Decode.(t x @@ { d; lexemes = [] })
let pp ?minify t ppf x =
let buf = Buffer.create 42 in
let e = Jsonm.encoder ?minify (`Buffer buf) in
encode t e x;
ignore (Jsonm.encode e `End);
Fmt.string ppf (Buffer.contents buf)
let to_string ?minify t x = Fmt.to_to_string (pp ?minify t) x
let of_string x s = Decode.(t x @@ Json.decoder (`String s))
let decode_lexemes x ls = Decode.(t x @@ Json.decoder_of_lexemes ls)
let encode_assoc = Encode.assoc
let decode_assoc = Decode.assoc
| (*
* Copyright (c) 2016-2017 Thomas Gazagnaire <thomas@gazagnaire.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*) |
apply_results.mli | (** Types representing results of applying an operation.
These are used internally by [Apply], and can be used for experimenting
with protocol updates, by clients to print out a summary of the
operation at pre-injection simulation and at confirmation time,
and by block explorers.
*)
open Alpha_context
open Apply_operation_result
open Apply_internal_results
(** Result of applying a {!Operation.t}. Follows the same structure. *)
type 'kind operation_metadata = {contents : 'kind contents_result_list}
and packed_operation_metadata =
| Operation_metadata : 'kind operation_metadata -> packed_operation_metadata
| No_operation_metadata : packed_operation_metadata
(** Result of applying a {!Operation.contents_list}. Follows the same structure. *)
and 'kind contents_result_list =
| Single_result : 'kind contents_result -> 'kind contents_result_list
| Cons_result :
'kind Kind.manager contents_result
* 'rest Kind.manager contents_result_list
-> ('kind * 'rest) Kind.manager contents_result_list
and packed_contents_result_list =
| Contents_result_list :
'kind contents_result_list
-> packed_contents_result_list
(** Result of applying an {!Operation.contents}. Follows the same structure. *)
and 'kind contents_result =
| Preendorsement_result : {
balance_updates : Receipt.balance_updates;
delegate : Signature.public_key_hash;
consensus_key : Signature.public_key_hash;
preendorsement_power : int;
}
-> Kind.preendorsement contents_result
| Endorsement_result : {
balance_updates : Receipt.balance_updates;
delegate : Signature.public_key_hash;
consensus_key : Signature.public_key_hash;
endorsement_power : int;
}
-> Kind.endorsement contents_result
| Dal_slot_availability_result : {
delegate : Signature.Public_key_hash.t;
}
-> Kind.dal_slot_availability contents_result
| Seed_nonce_revelation_result :
Receipt.balance_updates
-> Kind.seed_nonce_revelation contents_result
| Vdf_revelation_result :
Receipt.balance_updates
-> Kind.vdf_revelation contents_result
| Double_endorsement_evidence_result :
Receipt.balance_updates
-> Kind.double_endorsement_evidence contents_result
| Double_preendorsement_evidence_result :
Receipt.balance_updates
-> Kind.double_preendorsement_evidence contents_result
| Double_baking_evidence_result :
Receipt.balance_updates
-> Kind.double_baking_evidence contents_result
| Activate_account_result :
Receipt.balance_updates
-> Kind.activate_account contents_result
| Proposals_result : Kind.proposals contents_result
| Ballot_result : Kind.ballot contents_result
| Drain_delegate_result : {
balance_updates : Receipt.balance_updates;
allocated_destination_contract : bool;
}
-> Kind.drain_delegate contents_result
| Manager_operation_result : {
balance_updates : Receipt.balance_updates;
operation_result : 'kind manager_operation_result;
internal_operation_results : packed_internal_operation_result list;
}
-> 'kind Kind.manager contents_result
and packed_contents_result =
| Contents_result : 'kind contents_result -> packed_contents_result
and 'kind manager_operation_result =
( 'kind,
'kind Kind.manager,
'kind successful_manager_operation_result )
operation_result
(** Result of applying a transaction. *)
and successful_transaction_result =
Apply_internal_results.successful_transaction_result
(** Result of applying an origination. *)
and successful_origination_result =
Apply_internal_results.successful_origination_result
(** Result of applying an external {!manager_operation_content}. *)
and _ successful_manager_operation_result =
| Reveal_result : {
consumed_gas : Gas.Arith.fp;
}
-> Kind.reveal successful_manager_operation_result
| Transaction_result :
successful_transaction_result
-> Kind.transaction successful_manager_operation_result
| Origination_result :
successful_origination_result
-> Kind.origination successful_manager_operation_result
| Delegation_result : {
consumed_gas : Gas.Arith.fp;
}
-> Kind.delegation successful_manager_operation_result
| Register_global_constant_result : {
(* The manager submitting the operation must pay
the cost of storage for the registered value.
We include the balance update here. *)
balance_updates : Receipt.balance_updates;
(* Gas consumed while validating and storing the registered
value. *)
consumed_gas : Gas.Arith.fp;
(* The size of the registered value in bytes.
Currently, this is simply the number of bytes in the binary
serialization of the Micheline value. *)
size_of_constant : Z.t;
(* The address of the newly registered value, being
the hash of its binary serialization. This could be
calulated on demand but we include it here in the
receipt for flexibility in the future. *)
global_address : Script_expr_hash.t;
}
-> Kind.register_global_constant successful_manager_operation_result
| Set_deposits_limit_result : {
consumed_gas : Gas.Arith.fp;
}
-> Kind.set_deposits_limit successful_manager_operation_result
| Increase_paid_storage_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
}
-> Kind.increase_paid_storage successful_manager_operation_result
| Update_consensus_key_result : {
consumed_gas : Gas.Arith.fp;
}
-> Kind.update_consensus_key successful_manager_operation_result
| Tx_rollup_origination_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
originated_tx_rollup : Tx_rollup.t;
}
-> Kind.tx_rollup_origination successful_manager_operation_result
| Tx_rollup_submit_batch_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
paid_storage_size_diff : Z.t;
}
-> Kind.tx_rollup_submit_batch successful_manager_operation_result
| Tx_rollup_commit_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
}
-> Kind.tx_rollup_commit successful_manager_operation_result
| Tx_rollup_return_bond_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
}
-> Kind.tx_rollup_return_bond successful_manager_operation_result
| Tx_rollup_finalize_commitment_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
level : Tx_rollup_level.t;
}
-> Kind.tx_rollup_finalize_commitment successful_manager_operation_result
| Tx_rollup_remove_commitment_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
level : Tx_rollup_level.t;
}
-> Kind.tx_rollup_remove_commitment successful_manager_operation_result
| Tx_rollup_rejection_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
}
-> Kind.tx_rollup_rejection successful_manager_operation_result
| Tx_rollup_dispatch_tickets_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
paid_storage_size_diff : Z.t;
}
-> Kind.tx_rollup_dispatch_tickets successful_manager_operation_result
| Transfer_ticket_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
paid_storage_size_diff : Z.t;
}
-> Kind.transfer_ticket successful_manager_operation_result
| Dal_publish_slot_header_result : {
consumed_gas : Gas.Arith.fp;
}
-> Kind.dal_publish_slot_header successful_manager_operation_result
| Sc_rollup_originate_result : {
balance_updates : Receipt.balance_updates;
address : Sc_rollup.Address.t;
genesis_commitment_hash : Sc_rollup.Commitment.Hash.t;
consumed_gas : Gas.Arith.fp;
size : Z.t;
}
-> Kind.sc_rollup_originate successful_manager_operation_result
| Sc_rollup_add_messages_result : {
consumed_gas : Gas.Arith.fp;
inbox_after : Sc_rollup.Inbox.t;
}
-> Kind.sc_rollup_add_messages successful_manager_operation_result
| Sc_rollup_cement_result : {
consumed_gas : Gas.Arith.fp;
inbox_level : Raw_level.t;
}
-> Kind.sc_rollup_cement successful_manager_operation_result
| Sc_rollup_publish_result : {
consumed_gas : Gas.Arith.fp;
staked_hash : Sc_rollup.Commitment.Hash.t;
published_at_level : Raw_level.t;
balance_updates : Receipt.balance_updates;
}
-> Kind.sc_rollup_publish successful_manager_operation_result
| Sc_rollup_refute_result : {
consumed_gas : Gas.Arith.fp;
game_status : Sc_rollup.Game.status;
balance_updates : Receipt.balance_updates;
}
-> Kind.sc_rollup_refute successful_manager_operation_result
| Sc_rollup_timeout_result : {
consumed_gas : Gas.Arith.fp;
game_status : Sc_rollup.Game.status;
balance_updates : Receipt.balance_updates;
}
-> Kind.sc_rollup_timeout successful_manager_operation_result
| Sc_rollup_execute_outbox_message_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
paid_storage_size_diff : Z.t;
}
-> Kind.sc_rollup_execute_outbox_message
successful_manager_operation_result
| Sc_rollup_recover_bond_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
}
-> Kind.sc_rollup_recover_bond successful_manager_operation_result
| Sc_rollup_dal_slot_subscribe_result : {
consumed_gas : Gas.Arith.fp;
slot_index : Dal.Slot_index.t;
level : Raw_level.t;
}
-> Kind.sc_rollup_dal_slot_subscribe successful_manager_operation_result
| Zk_rollup_origination_result : {
balance_updates : Receipt.balance_updates;
originated_zk_rollup : Zk_rollup.t;
consumed_gas : Gas.Arith.fp;
(* Number of bytes allocated by the ZKRU origination.
Used to burn storage fees. *)
storage_size : Z.t;
}
-> Kind.zk_rollup_origination successful_manager_operation_result
| Zk_rollup_publish_result : {
balance_updates : Receipt.balance_updates;
consumed_gas : Gas.Arith.fp;
paid_storage_size_diff : Z.t;
}
-> Kind.zk_rollup_publish successful_manager_operation_result
and packed_successful_manager_operation_result =
| Successful_manager_result :
'kind successful_manager_operation_result
-> packed_successful_manager_operation_result
val pack_migration_operation_results :
Migration.origination_result list ->
packed_successful_manager_operation_result list
(** Serializer for {!packed_operation_result}. *)
val operation_metadata_encoding : packed_operation_metadata Data_encoding.t
val operation_data_and_metadata_encoding :
(Operation.packed_protocol_data * packed_operation_metadata) Data_encoding.t
type 'kind contents_and_result_list =
| Single_and_result :
'kind Alpha_context.contents * 'kind contents_result
-> 'kind contents_and_result_list
| Cons_and_result :
'kind Kind.manager Alpha_context.contents
* 'kind Kind.manager contents_result
* 'rest Kind.manager contents_and_result_list
-> ('kind * 'rest) Kind.manager contents_and_result_list
type packed_contents_and_result_list =
| Contents_and_result_list :
'kind contents_and_result_list
-> packed_contents_and_result_list
val contents_and_result_list_encoding :
packed_contents_and_result_list Data_encoding.t
val pack_contents_list :
'kind contents_list ->
'kind contents_result_list ->
'kind contents_and_result_list
val unpack_contents_list :
'kind contents_and_result_list ->
'kind contents_list * 'kind contents_result_list
val to_list : packed_contents_result_list -> packed_contents_result list
type ('a, 'b) eq = Eq : ('a, 'a) eq
val kind_equal_list :
'kind contents_list ->
'kind2 contents_result_list ->
('kind, 'kind2) eq option
type block_metadata = {
proposer : Consensus_key.t;
baker : Consensus_key.t;
level_info : Level.t;
voting_period_info : Voting_period.info;
nonce_hash : Nonce_hash.t option;
consumed_gas : Gas.Arith.fp;
deactivated : Signature.Public_key_hash.t list;
balance_updates : Receipt.balance_updates;
liquidity_baking_toggle_ema : Liquidity_baking.Toggle_EMA.t;
implicit_operations_results : packed_successful_manager_operation_result list;
dal_slot_availability : Dal.Endorsement.t option;
}
val block_metadata_encoding : block_metadata Data_encoding.encoding
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2022 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
ppextend.ml | open Util
open Pp
open Notation
open Constrexpr
(*s Pretty-print. *)
type ppbox =
| PpHB
| PpHOVB of int
| PpHVB of int
| PpVB of int
type ppcut =
| PpBrk of int * int
| PpFnl
let ppcmd_of_box = function
| PpHB -> h
| PpHOVB n -> hov n
| PpHVB n -> hv n
| PpVB n -> v n
let ppcmd_of_cut = function
| PpFnl -> fnl ()
| PpBrk(n1,n2) -> brk(n1,n2)
type pattern_quote_style = QuotedPattern | NotQuotedPattern
type unparsing =
| UnpMetaVar of entry_relative_level * Extend.side option
| UnpBinderMetaVar of entry_relative_level * pattern_quote_style
| UnpListMetaVar of entry_relative_level * unparsing list * Extend.side option
| UnpBinderListMetaVar of bool * unparsing list
| UnpTerminal of string
| UnpBox of ppbox * unparsing Loc.located list
| UnpCut of ppcut
type unparsing_rule = unparsing list
let rec unparsing_eq unp1 unp2 = match (unp1,unp2) with
| UnpMetaVar (p1,s1), UnpMetaVar (p2,s2) -> entry_relative_level_eq p1 p2 && s1 = s2
| UnpBinderMetaVar (p1,s1), UnpBinderMetaVar (p2,s2) -> entry_relative_level_eq p1 p2 && s1 = s2
| UnpListMetaVar (p1,l1,s1), UnpListMetaVar (p2,l2,s2) -> entry_relative_level_eq p1 p2 && List.for_all2eq unparsing_eq l1 l2 && s1 = s2
| UnpBinderListMetaVar (b1,l1), UnpBinderListMetaVar (b2,l2) -> b1 = b2 && List.for_all2eq unparsing_eq l1 l2
| UnpTerminal s1, UnpTerminal s2 -> String.equal s1 s2
| UnpBox (b1,l1), UnpBox (b2,l2) -> b1 = b2 && List.for_all2eq unparsing_eq (List.map snd l1) (List.map snd l2)
| UnpCut p1, UnpCut p2 -> p1 = p2
| (UnpMetaVar _ | UnpBinderMetaVar _ | UnpListMetaVar _ |
UnpBinderListMetaVar _ | UnpTerminal _ | UnpBox _ | UnpCut _), _ -> false
(* Register generic and specific printing rules *)
type notation_printing_rules = {
notation_printing_unparsing : unparsing_rule;
notation_printing_level : entry_level;
}
type generic_notation_printing_rules = {
notation_printing_reserved : bool;
notation_printing_rules : notation_printing_rules;
}
let generic_notation_printing_rules =
Summary.ref ~name:"generic-notation-printing-rules" (NotationMap.empty : generic_notation_printing_rules NotationMap.t)
let specific_notation_printing_rules =
Summary.ref ~name:"specific-notation-printing-rules" (SpecificNotationMap.empty : notation_printing_rules SpecificNotationMap.t)
let declare_generic_notation_printing_rules ntn rules =
generic_notation_printing_rules := NotationMap.add ntn rules !generic_notation_printing_rules
let declare_specific_notation_printing_rules specific_ntn rules =
specific_notation_printing_rules := SpecificNotationMap.add specific_ntn rules !specific_notation_printing_rules
let has_generic_notation_printing_rule ntn =
try (NotationMap.find ntn !generic_notation_printing_rules).notation_printing_reserved
with Not_found -> false
let find_generic_notation_printing_rule ntn =
NotationMap.find ntn !generic_notation_printing_rules
let find_specific_notation_printing_rule specific_ntn =
SpecificNotationMap.find specific_ntn !specific_notation_printing_rules
let find_notation_printing_rule which ntn =
try match which with
| None -> raise Not_found (* Normally not the case *)
| Some which -> (find_specific_notation_printing_rule (which,ntn))
with Not_found -> (find_generic_notation_printing_rule ntn).notation_printing_rules
| (************************************************************************)
(* * The Coq Proof Assistant / The Coq Development Team *)
(* v * Copyright INRIA, CNRS and contributors *)
(* <O___,, * (see version control and CREDITS file for authors & dates) *)
(* \VV/ **************************************************************)
(* // * This file is distributed under the terms of the *)
(* * GNU Lesser General Public License Version 2.1 *)
(* * (see LICENSE file for the text of the license) *)
(************************************************************************)
|
termslinks.mli |
(*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details (in file LICENSE).
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*)
val equal_terms_with_links : Types.term -> Types.term -> bool
val equal_facts_with_links : Types.fact -> Types.fact -> bool
val equal_closed_terms : Types.term -> Types.term -> bool
val equal_tags : Types.label -> Types.label -> bool
val equal_constra : Types.constraints -> Types.constraints -> bool
val match_terms : Types.term -> Types.term -> unit
val get_vars : Types.binder list ref -> Types.term -> unit
val has_vars : Types.term -> bool
| (*************************************************************
* *
* Cryptographic protocol verifier *
* *
* Bruno Blanchet, Vincent Cheval, and Marc Sylvestre *
* *
* Copyright (C) INRIA, CNRS 2000-2021 *
* *
*************************************************************) |
owl_sparse.ml |
(** Sparse data structures: matrix & ndarray *)
module Ndarray = Owl_sparse_ndarray
module Matrix = Owl_sparse_matrix
module Dok_matrix = Owl_sparse_dok_matrix
| (*
* OWL - OCaml Scientific and Engineering Computing
* Copyright (c) 2016-2020 Liang Wang <liang.wang@cl.cam.ac.uk>
*) |
binary_description.mli | (** Like most other [.mli] files in this directory, this is not intended for
end-users. Instead, the interface from this file is used internally to
assemble the end-user-intended module {!Data_encoding}. Refer to that module
for doucmentation. *)
val describe : 'a Encoding.t -> Binary_schema.t
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
FilePath_type.ml | type current_dir_type =
Short
| Long
type filename_part =
Root of string
| ParentDir
| CurrentDir of current_dir_type
| Component of string
type filename = string
type extension = string
(* Utility function to parse filename *)
let begin_string str lst = (str, lst)
let add_string str1 (str2, lst) = (str1 ^ str2, lst)
let end_string (str, lst) = (Component str) :: lst
(* Definition of the caracteristic length of a path *)
let path_length = 80
| (******************************************************************************)
(* ocaml-fileutils: files and filenames common operations *)
(* *)
(* Copyright (C) 2003-2014, Sylvain Le Gall *)
(* *)
(* This library is free software; you can redistribute it and/or modify it *)
(* under the terms of the GNU Lesser General Public License as published by *)
(* the Free Software Foundation; either version 2.1 of the License, or (at *)
(* your option) any later version, with the OCaml static compilation *)
(* exception. *)
(* *)
(* This library is distributed in the hope that it will be useful, but *)
(* WITHOUT ANY WARRANTY; without even the implied warranty of *)
(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the file *)
(* COPYING for more details. *)
(* *)
(* You should have received a copy of the GNU Lesser General Public License *)
(* along with this library; if not, write to the Free Software Foundation, *)
(* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA *)
(******************************************************************************)
|
divides.c |
#include "fq_nmod_poly.h"
#ifdef T
#undef T
#endif
#define T fq_nmod
#define CAP_T FQ_NMOD
#include "fq_poly_templates/divides.c"
#undef CAP_T
#undef T
| /*
Copyright (C) 2013 Mike Hansen
This file is part of FLINT.
FLINT is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <https://www.gnu.org/licenses/>.
*/ |
che_X_____auto.c |
/* -------------------------------------------------------*/
/* The following code is generated automagically with */
/* generate_auto.py. Yes, it is fairly ugly ;-) */
/* -------------------------------------------------------*/
/* Class dir used: ../CLASS_LISTS_D7ND/ */
/* CLASS_FGUSM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FHHSM-FSLM31-D : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_S0Y.csv 1 */
/* CLASS_FGUPS-FFSM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNM-FFMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMS32-S : protocol_G-E--_208_C18_F1_SE_CS_SOS_SP_PS_S5PRR_RG_S04AN.csv 47 */
/* CLASS_FGHSF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-SSLM33-M : protocol_G-E--_200_B02_F1_SE_CS_SP_PI_S2k.csv 80 */
/* CLASS_FGUPS-FSLM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUHPM-FFSF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 16 */
/* CLASS_FGHNF-FFMM11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSS-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNM-FFMM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUHPM-FFSF21-M : protocol_H----_047_B31_F1_PI_AE_R4_CS_SP_S2S.csv 52 */
/* CLASS_FGHSM-FSLF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSS-FFSM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 47 */
/* CLASS_FGUSM-FFSF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUHPM-FFSF21-D : protocol_H----_047_B31_F1_PI_AE_R4_CS_SP_S2S.csv 6 */
/* CLASS_FGHSF-FFMS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FGHNF-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 20 */
/* CLASS_FUHNF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 16 */
/* CLASS_FGUSM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FHHSF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFMF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FSLS33-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 2 */
/* CLASS_FHHNM-FFMF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFMM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFSF21-D : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 7 */
/* CLASS_FHHNM-FSLM31-M : protocol_G----_0021_10gd3.csv 7 */
/* CLASS_FHHSM-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSS-FFMF33-S : protocol_208_C09_12_F1_SE_CS_SP_PS_S070I.csv 41 */
/* CLASS_FHUNF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 39 */
/* CLASS_FGUSS-FFMM33-S : protocol_G-E--_107_B42_F1_PI_SE_Q4_CS_SP_PS_S0YI.csv 3 */
/* CLASS_FHHSM-SMLM31-M : protocol_G----_0021_10gd3.csv 57 */
/* CLASS_FUUSM-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S04AN.csv 2 */
/* CLASS_FGHSF-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 13 */
/* CLASS_FHUSF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FUHPS-FFSF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FGUSF-FFMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUPS-FFSM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPF-FFMM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 22 */
/* CLASS_FGHSF-FFMS21-S : protocol_G-E--_107_C36_F1_PI_AE_Q4_CS_SP_PS_S0Y.csv 43 */
/* CLASS_FGHSF-FSLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUNM-FFMF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSF-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 2 */
/* CLASS_FHUNM-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLM32-M : protocol_C07_19_nc_SOS_SAT001_MinMin_p005000_rr.csv 40 */
/* CLASS_FGUNM-FFMF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUNS-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSLM31-M : protocol_G-E--_207_C01_F1_SE_CS_SP_PI_S5PRR_S0Y.csv 102 */
/* CLASS_FGHSF-FSLM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_S032N.csv 62 */
/* CLASS_FHHSS-FFMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSS-FFSM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPF-FFSF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHPF-FFMF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNS-FFMF11-S : protocol_G-E--_207_C18_F1_SP_PI_S0Y.csv 12 */
/* CLASS_FGHSM-FSLM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 328 */
/* CLASS_FGHSM-SMLF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUPM-SMLM31-D : protocol_SAT001_MinMin_p002000_NN.csv 7 */
/* CLASS_FGUNS-FFMF11-S : protocol_G-E--_208_C47_F1_SE_CS_SP_PS_S0Y.csv 2 */
/* CLASS_FGUNF-FSMS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNM-FFMF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FFLM33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSM-FSLM31-S : protocol_G-E--_212_C18_F1_AE_Q12_CS_SP_S2S.csv 3 */
/* CLASS_FGUSM-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLM21-M : protocol_G-E--_208_C18_SOS_F1_SE_CS_SP_PS_S4c.csv 409 */
/* CLASS_FHHSM-SSLM31-M : protocol_G-E--_207_C18_F1_AE_CS_SP_PS_S0Y.csv 2 */
/* CLASS_FGHSS-SSLM32-M : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FGHSS-FSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUPM-FFMF33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FFMF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S05BN.csv 1 */
/* CLASS_FGUSM-FFSS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUPS-FSLM32-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 2 */
/* CLASS_FGHSM-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 18 */
/* CLASS_FGHSF-FFSF00-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S2SA.csv 12 */
/* CLASS_FGHSS-FFLS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FSMM00-S : protocol_G-N--_023_B07_F1_SP_PI_Q7_CS_SP_CO_S5PRR_S0Y.csv 119 */
/* CLASS_FGUSF-FFSM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSLS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FHHNF-FFSF22-M : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_PS_S2U.csv 1 */
/* CLASS_FGHNF-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHNF-FFSM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFMM21-S : protocol_G-E--_110_C45_F1_PI_SE_CS_SP_PS_S4S.csv 43 */
/* CLASS_FUUPF-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FFMF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 34 */
/* CLASS_FHHNF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHNF-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FGHSS-FFSM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-SSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPM-FFMM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 13 */
/* CLASS_FHUNF-FFSF21-D : protocol_U----_206e_02_C10_23_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FHUSM-FFSS33-S : protocol_G-E--_110_C45_F1_PI_SE_CS_SP_PS_S4S.csv 2 */
/* CLASS_FHUNM-FFMM21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGHSS-FFMM32-M : protocol_G-E--_208_B07_F1_S5PRR_SE_CS_SP_PS_S0Y.csv 7 */
/* CLASS_FGUSF-FSLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNF-FMLF00-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 25 */
/* CLASS_FGHNF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 21 */
/* CLASS_FHHNF-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUSF-FSLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUNF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUNF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHHSS-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFSM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FHUNM-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSF-FFMM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FHUPF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 17 */
/* CLASS_FGHSM-FSLF33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFLF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 3 */
/* CLASS_FGHNF-SMLM00-S : protocol_H----_011_C07_F1_PI_SE_SP_S0V.csv 16 */
/* CLASS_FGHNF-FMLF31-S : protocol_G-E--_208_C18_F1_AE_CS_SP_PS_S3S.csv 3 */
/* CLASS_FGHNF-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FUHPS-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FSLM33-S : protocol_H----_042_B03_F1_AE_Q4_SP_S2S.csv 7 */
/* CLASS_FHUNM-FFMS21-D : protocol_G-E--_208_C18_SOS_F1_SE_CS_SP_PS_S4c.csv 3 */
/* CLASS_FHUSM-FFSF22-S : protocol_H----_047_B31_F1_PI_AE_R4_CS_SP_S2S.csv 36 */
/* CLASS_FUUPM-FFSS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FMLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 3 */
/* CLASS_FHUNM-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUPS-FSLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 2 */
/* CLASS_FGHSM-FFLS21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUNF-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFMM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGHSS-FFMM32-S : protocol_G-E--_215_C46_F1_AE_CS_SP_PS_S2S.csv 6 */
/* CLASS_FGHSS-FFMS33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFMF21-D : protocol_G-E--_110_C45_F1_PI_SE_CS_SP_PS_S4S.csv 4 */
/* CLASS_FGHNS-FFMF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFMM22-S : protocol_G-E--_208_C18_F1_AE_CS_SP_PS_S3S.csv 5 */
/* CLASS_FHHNM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-SMLM31-M : protocol_SAT001_MinMin_p002000_NN.csv 39 */
/* CLASS_FGHNM-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHNF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSM-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUNS-SMLM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNM-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FFMF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FFMS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFMM22-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 18 */
/* CLASS_FGUNF-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNF-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FGHSM-FFLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPM-FSLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUPS-FFSF22-M : protocol_H----_102_C18_F1_PI_AE_CS_SP_PS_S2S.csv 4 */
/* CLASS_FGUNF-FFSF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSF-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FSLS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSM-FFLM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHPM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFSF22-S : protocol_G-E--_300_C18_F1_SE_CS_SP_PS_S0Y.csv 16 */
/* CLASS_FGHSM-FFLF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 19 */
/* CLASS_FGUNF-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGUSM-FFMF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNM-FSLF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-SMLF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 1 */
/* CLASS_FGHSM-FFMF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S4b.csv 43 */
/* CLASS_FUHNS-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSS-FFMF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FGHNF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 98 */
/* CLASS_FHHNF-FFSS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FMLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FFLS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FFMF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNF-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 27 */
/* CLASS_FGHNF-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUSS-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFSM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGHSF-FFLM11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FFMF21-M : protocol_G-E--_200_B02_F1_SE_CS_SP_PI_S0S.csv 12 */
/* CLASS_FHUNF-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUNF-FFLM00-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S00I.csv 2 */
/* CLASS_FGHNF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 61 */
/* CLASS_FGUSS-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNM-FFLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUNF-MMLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFLS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFMF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGUNF-FMLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGHNF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 67 */
/* CLASS_FGHNS-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNF-FFSF22-M : protocol_G----_0019_C18_F1_PI_SE_CS_SP_S0Y.csv 56 */
/* CLASS_FHUSF-FFMM32-S : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 2 */
/* CLASS_FUHPS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 14 */
/* CLASS_FGUSF-FFMF33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFSF22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S00.csv 4 */
/* CLASS_FGHSF-FFMF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AI.csv 44 */
/* CLASS_FGUSF-FFLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFMF00-S : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 6 */
/* CLASS_FGUSS-FFSM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPS-FFSF33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFMF21-D : protocol_H----_047_C09_12_F1_AE_ND_CS_SP_S5PRR_S2S.csv 61 */
/* CLASS_FGHNF-FMLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUNF-FFMM33-S : protocol_G-E--_208_C47_F1_SE_CS_SP_PS_S0Y.csv 1 */
/* CLASS_FGHSM-FFLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSM32-M : protocol_G-E--_107_B42_F1_PI_SE_Q4_CS_SP_PS_S5PRR_S0Y.csv 1 */
/* CLASS_FUUPM-FFMF21-M : protocol_G-E--_300_C18_F1_SE_CS_SP_PS_S0Y.csv 3 */
/* CLASS_FHHSF-SMLM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFMF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFMF21-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 41 */
/* CLASS_FUUSF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNS-FFSM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFLS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 40 */
/* CLASS_FUHPF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUPS-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSS-SMLF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNS-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSLM22-M : protocol_G----_402_C05_02_F1_SE_CS_SP_PS_RG_S04AN.csv 27 */
/* CLASS_FGUSS-FFSS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FSLM32-S : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_PS_S0S.csv 13 */
/* CLASS_FGUSM-FFMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUSF-FFMS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUSM-FFSF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S0Y_ni.csv 5 */
/* CLASS_FUUNS-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLS33-S : protocol_G-E--_008_C45_F1_PI_SE_Q4_CS_SP_S4SI.csv 8 */
/* CLASS_FGHSF-FSLS33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FGHSF-FFLM33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FFMS21-M : protocol_G-E--_110_C45_F1_PI_SE_CS_SP_PS_S4S.csv 8 */
/* CLASS_FHHNS-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-SSLF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNM-FFMF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSF-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 1 */
/* CLASS_FUUPS-FFSS33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNS-FFLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FSLF22-S : protocol_G-E--_107_C45_F1_PI_AE_Q7_CS_SP_PS_S0Y.csv 1 */
/* CLASS_FHUSS-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y.csv 2 */
/* CLASS_FHUNF-FSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUSF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFMM21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUPM-FFSS22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FMLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSM-SMLM31-D : protocol_G-E--_200_C45_F1_AE_CS_SP_S0Y.csv 2 */
/* CLASS_FUUPS-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-SMLM32-M : protocol_G-E--_212_C18_F1_AE_Q12_CS_SP_S2S.csv 60 */
/* CLASS_FHHNF-SSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FUHSF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FFMS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 30 */
/* CLASS_FGHSM-FSLM31-M : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 79 */
/* CLASS_FGHSS-FFMF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNS-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S2v.csv 87 */
/* CLASS_FGUPS-FFMM32-M : protocol_G-E--_208_C02---_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGHSM-FFMF22-S : protocol_G-E--_300_C18_F1_SE_CS_SP_PS_S0Y.csv 4 */
/* CLASS_FGHSM-FFMF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGHSF-FSLM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 15 */
/* CLASS_FGHSM-SSLM33-D : protocol_G-E--_200_C45_F1_SE_CS_SP_PI_CO_S5PRR_S0V.csv 2 */
/* CLASS_FGHSF-FFMM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 27 */
/* CLASS_FHHSM-FFMF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 2 */
/* CLASS_FHHSF-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 45 */
/* CLASS_FGHNF-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUHPM-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-SMLS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNS-FSLM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSS-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNS-FFMF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSF21-S : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_PS_S0S.csv 33 */
/* CLASS_FGUPF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFMF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-SMLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 14 */
/* CLASS_FGHPF-SMLM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPM-FFSS21-M : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGUSM-FFLS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S0Y_ni.csv 1 */
/* CLASS_FGUPM-FFSF22-M : protocol_H----_047_C09_12_F1_AE_ND_CS_SP_S5PRR_S2S.csv 4 */
/* CLASS_FGHNF-FFSS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFLF00-S : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 11 */
/* CLASS_FUHPF-FFSF32-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 1 */
/* CLASS_FGHNF-FSMS00-S : protocol_G-N--_023_B07_F1_SP_PI_Q7_CS_SP_CO_S5PRR_S0Y.csv 23 */
/* CLASS_FHUSM-FFSS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFSF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHPF-FSLM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSM-FFMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNF-FFMF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 16 */
/* CLASS_FGUPS-SSLM32-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 1 */
/* CLASS_FGUSM-FFMS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHPF-FSLM21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUSF-FSMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FUUPS-FFSF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 38 */
/* CLASS_FGHSM-FFMM21-S : protocol_G-E--_208_C02CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 81 */
/* CLASS_FGHSF-SMLM22-M : protocol_G----_404_C05_02_F1_SE_CS_SP_PS_RG_S04AN.csv 7 */
/* CLASS_FHHPF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 1 */
/* CLASS_FGUSF-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPS-FFSF22-M : protocol_U----_206d_05_C11_08_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN.csv 33 */
/* CLASS_FGHSF-FFMS33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHPF-FSLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FFMS32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 2 */
/* CLASS_FGUSF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FHUSM-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 1 */
/* CLASS_FHUNS-FFSF22-M : protocol_G-E--_060_C18_F1_PI_SE_CS_SP_CO_S0Y.csv 19 */
/* CLASS_FUUNS-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGUNF-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSS-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGHSF-SMLS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-SMLM32-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 4 */
/* CLASS_FUUSF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUPF-FFLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHSM-SSLM31-D : protocol_G-E--_207_C18_F1_AE_CS_SP_PS_S0Y.csv 1 */
/* CLASS_FGHNF-FSLM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGHSF-FSLF33-S : protocol_G-E--_008_C45_F1_PI_SE_Q4_CS_SP_S4SI.csv 6 */
/* CLASS_FGUNF-FFSS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNF-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUSM-FFLS33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNF-FFSS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUPF-FSLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSS-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUNF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 22 */
/* CLASS_FHUNF-SMLM00-S : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 3 */
/* CLASS_FUHNF-FFSM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHPF-FSLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUSS-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 9 */
/* CLASS_FGHSS-FSLM31-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 27 */
/* CLASS_FGUSF-FFMM33-M : protocol_H----_047_B31_F1_PI_AE_R4_CS_SP_S4c.csv 2 */
/* CLASS_FGUNF-SMLF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUSS-FFSF21-S : protocol_G-E--_107_B00_00_F1_PI_AE_Q4_CS_SP_PS_S071I.csv 17 */
/* CLASS_FUUSF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSM-FFLM21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FSLM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNF-FFMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FGHSM-FSMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 200 */
/* CLASS_FGHNF-FFLS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSS-FFSF22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FHHSF-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FSLS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSS-FFSF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGHSS-FFMS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FGHPF-FSLM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FGUNS-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSS-FFMS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSF-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUHPM-FFMF21-D : protocol_H----_047_B31_F1_PI_AE_R4_CS_SP_S2S.csv 24 */
/* CLASS_FGHSF-SMLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNF-FFMF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHNF-FMLM32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 12 */
/* CLASS_FUHNF-FFSM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FMLM31-S : protocol_U----_043_B31_F1_PI_AE_CS_SP_S2S.csv 6 */
/* CLASS_FHHSF-FFSS21-S : protocol_G-E--_110_C45_F1_PI_SE_CS_SP_PS_S4S.csv 4 */
/* CLASS_FGHNF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 34 */
/* CLASS_FHUSF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNF-FSLF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 34 */
/* CLASS_FHUNS-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 2 */
/* CLASS_FGUSF-FFLF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUNS-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSS-FFMF22-D : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 12 */
/* CLASS_FGUNF-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSM-SSLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNM-FFMS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 3 */
/* CLASS_FGUNM-FFMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSS-FFMF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUHNF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-SSLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y.csv 16 */
/* CLASS_FHUNS-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FFMF21-S : protocol_G-E--_200_C45_F1_SE_CS_SP_PI_CO_S5PRR_S0V.csv 6 */
/* CLASS_FGHNF-SMLM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 3 */
/* CLASS_FHHSF-FFMS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FSLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FGUNF-FSLF33-S : protocol_G-E--_300_C18_F1_URBAN_S0Y.csv 1 */
/* CLASS_FGUNF-FFMS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUNF-FFSS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHHNF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUNF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y.csv 4 */
/* CLASS_FHUNM-FFSF22-M : protocol_G-E--_300_C01_S5PRR_S00.csv 4 */
/* CLASS_FHUNM-FFMS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSF-SMLM33-S : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 48 */
/* CLASS_FHUNM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S3b.csv 75 */
/* CLASS_FHUNF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFSF22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNM-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNF-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FUHNF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSS-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FHUNM-FFMF31-S : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 1 */
/* CLASS_FHUSM-FFMM21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FFMF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFMM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y.csv 2 */
/* CLASS_FGHSF-SMLF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHPS-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 183 */
/* CLASS_FHUSF-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 14 */
/* CLASS_FGHNM-FFMF21-S : protocol_G-E--_110_C45_F1_PI_SE_CS_SP_PS_S4S.csv 16 */
/* CLASS_FHUSM-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-SMLF00-S : protocol_G-E--_208_B07_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGUNF-FFMS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUSM-FFSM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSM-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 3 */
/* CLASS_FUUPF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-SSLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SOS_SP_PS_S5PRR_RG_S04AN.csv 67 */
/* CLASS_FGUPS-SSLF32-D : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FHHNS-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGHSM-FSLS33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUSM-FSLS33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGHSM-SSLM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AI.csv 44 */
/* CLASS_FUUPM-FFLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSM-MMLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSS-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FHHNM-FFMS21-D : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 3 */
/* CLASS_FGHSM-FSLS33-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUPF-FSLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGUSF-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FSLM31-D : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 41 */
/* CLASS_FHHSF-FFMF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUSS-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNM-FFMF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNF-FFMS00-S : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_PS_S0S.csv 13 */
/* CLASS_FGUNS-FFMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSS-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFSF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUPM-FFMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFSF22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S3b.csv 4 */
/* CLASS_FHUSF-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FUUPM-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFMM21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNS-FFMS21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FHUNS-FFSF21-M : protocol_H----_011_C07_F1_PI_AE_Q4_CS_SP_PS_S0V.csv 88 */
/* CLASS_FGHSM-FFMM21-M : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 23 */
/* CLASS_FHUSF-FFSS21-S : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 7 */
/* CLASS_FUUPM-FFMS33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUPF-FSLM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FHUPM-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 1 */
/* CLASS_FGHNF-SMLF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FSLS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFSM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHHNM-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFSF21-D : protocol_H----_102_C18_F1_PI_AE_CS_SP_PS_S2S.csv 1 */
/* CLASS_FGHSM-FFMS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S2mI.csv 38 */
/* CLASS_FGHSM-FSLS31-M : protocol_G-E--_200_B02_F1_AE_CS_SP_PI_S2k.csv 35 */
/* CLASS_FGUSF-FFMM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FSLS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGHSF-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SOS_SP_PS_S5PRR_RG_S04AN.csv 72 */
/* CLASS_FGHSM-FSLS32-M : protocol_G-E--_208_C18--C_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUPF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGHNF-FFLF11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSF-FFSS21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FSLS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFMM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFLF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNF-FSLM00-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 44 */
/* CLASS_FGHSM-FFMS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSS-FFSF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FHUNF-SSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FFMS33-S : protocol_G-E--_208_C02AMC_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FGHSM-FSLM31-S : protocol_G-E--_302_C18_F1_URBAN_S0Y.csv 21 */
/* CLASS_FGUNM-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUNF-FFSF00-S : protocol_G-E--_107_C48_F1_PI_AE_Q4_CS_SP_PS_S0Y.csv 34 */
/* CLASS_FGHNF-FFMS31-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 7 */
/* CLASS_FUUNS-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 13 */
/* CLASS_FHHSF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FHUSF-FFMM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUHPF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSS-FFSF22-S : protocol_G----_402_C05_02_F1_SE_CS_SP_PS_RG_S04AN.csv 22 */
/* CLASS_FGHSF-FSLF31-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 3 */
/* CLASS_FHHSF-FFSM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNF-FFMS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPF-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNF-FFSS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-SSLF33-S : protocol_G-E--_092_C01_F1_AE_CS_SP_PS_CO_S0Y.csv 4 */
/* CLASS_FGUNF-FFMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-SMLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUPM-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGUNF-FFMS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUPS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFSM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FUHNF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGHSF-FSLF31-M : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 2 */
/* CLASS_FHHSS-FFMM21-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 2 */
/* CLASS_FGHPF-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSF-SMLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNM-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSS-FFSS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUNF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUNF-FMLS33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSM-FFMS21-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FUUPM-FFMF32-M : protocol_G-E--_300_C18_F1_SE_CS_SP_PS_S0Y.csv 18 */
/* CLASS_FGHSF-FSLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSM-SMLM33-D : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 123 */
/* CLASS_FHUNS-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNM-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNS-FFMS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFMF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FFMM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFSS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUSM-FFSS22-S : protocol_H----_047_C45_F1_AE_R8_CS_SP_S2S.csv 1 */
/* CLASS_FGHSF-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFMM21-M : protocol_G-E--_301_C18_F1_URBAN_S5PRR_RG_S04BN.csv 5 */
/* CLASS_FGHSF-FFSS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSM-FFSS21-S : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 13 */
/* CLASS_FHHNF-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHNF-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNM-FFMM22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S2v.csv 7 */
/* CLASS_FHHNF-FFMS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFMM00-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S0Y.csv 2 */
/* CLASS_FGHNM-FFMM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFSS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNS-FFSF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSF21-M : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 219 */
/* CLASS_FGHNM-FFMM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-SMLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSF-FSMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPM-FFLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGHSF-FSMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 13 */
/* CLASS_FGHSF-FSMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_S032N.csv 10 */
/* CLASS_FGUPM-FFLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFMM32-M : protocol_G-E--_208_C18C--_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FGUSF-FFMM32-S : protocol_G-E--_208_B07_F1_SE_CS_SP_PS_S4d.csv 5 */
/* CLASS_FGHNS-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSMM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGUSF-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FMLM21-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 14 */
/* CLASS_FGHSF-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 14 */
/* CLASS_FGHSF-FSMM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FGUPS-FFMF32-D : protocol_G----_402_C05_02_F1_SE_CS_SP_PS_RG_S04AN.csv 4 */
/* CLASS_FHHSM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AI.csv 15 */
/* CLASS_FGUSM-FMLM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNF-FSMF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPM-FFLF33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUPM-FFSF22-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 11 */
/* CLASS_FGHSM-FFMM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FSMF11-S : protocol_G-E--_208_C47_F1_SE_CS_SP_PS_S0Y.csv 4 */
/* CLASS_FGUSM-FSLS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSM-FFMS31-M : protocol_G-E--_301_C18_F1_URBAN_S5PRR_RG_S0Y.csv 36 */
/* CLASS_FUHNF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMM32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S2SA.csv 180 */
/* CLASS_FGUNM-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 28 */
/* CLASS_FHHNM-FFMF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFMF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUNM-FFSF21-S : protocol_G-E--_107_C45_F1_PI_AE_Q7_CS_SP_PS_S0Y.csv 1 */
/* CLASS_FGUNS-FFMS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUPM-FFLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNS-FSLM32-M : protocol_G-E--_302_C18_F1_URBAN_RG_S04BN.csv 207 */
/* CLASS_FHHSM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FSLF33-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FHUNM-FFMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSS-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FHUNM-FFMM21-M : protocol_G-E--_207_C18_F1_AE_CS_SP_PS_S0Y.csv 1 */
/* CLASS_FGUNS-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNM-FFMF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 2 */
/* CLASS_FHUNF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FUUNF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FHHNM-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMS32-M : protocol_G-E--_208_C18--C_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FHUNF-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSM-FFSF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FMLF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUPM-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 3 */
/* CLASS_FGHSM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGHSF-FSMF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-SMLS33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNF-FMLF33-S : protocol_G----_406_C05_02_F1_SE_CS_SP_PS_RG_S04AI.csv 2 */
/* CLASS_FGUSS-FFLS33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNM-FFMF22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFMS33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFSF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FUUPM-FFMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNF-FFLF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FHUNF-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUNF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FUUPM-FFSF32-D : protocol_G----_X1276__C12_02_nc_F1_AE_CS_SP_S5PRR_S2S.csv 5 */
/* CLASS_FGUNF-FFMF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 1 */
/* CLASS_FGHNF-FMLF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFLM31-M : protocol_208_C09_12_F1_SE_CS_SP_PS_S070I.csv 50 */
/* CLASS_FUUPM-FFSF32-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 31 */
/* CLASS_FUUNM-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUPS-FFSF21-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGHNF-FFMF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUPS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S04AN.csv 81 */
/* CLASS_FUUPM-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNF-FMLF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSM-FFMF33-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2S.csv 56 */
/* CLASS_FGUPF-SSLM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FUUPM-FFSF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFSM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 12 */
/* CLASS_FGHSF-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUNF-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHHNF-FFSF21-D : protocol_G-E--_209_C18_F1_AE_CS_SP_PI_S0Y.csv 1 */
/* CLASS_FGHPF-SSLM21-M : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_S0e.csv 2 */
/* CLASS_FUUSM-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNM-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUSM-FFSM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FFMM21-S : protocol_G-E--_006_C18_F1_PI_AE_Q4_CS_SP_S2S.csv 70 */
/* CLASS_FGUPF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNM-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNF-FMLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNM-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FGHSS-FSLM33-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 13 */
/* CLASS_FGUSF-SMLF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUPF-FFLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN.csv 17 */
/* CLASS_FUHPF-FFSF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 16 */
/* CLASS_FGHSM-FFLS31-S : protocol_G-E--_300_C01_F1_SE_CS_SP_S0Y.csv 3 */
/* CLASS_FGUSM-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FHHNF-FSLS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFLS31-D : protocol_G-E--_208_C02AMC_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNM-FFLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUPS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSM-FFLS31-M : protocol_U----_206d_00_C11_23_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FHUNM-FFMF22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUPM-FFMF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFMF31-S : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 27 */
/* CLASS_FGHNS-FFMF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 27 */
/* CLASS_FHHNS-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFMF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSM-FFMF21-M : protocol_G-E--_208_B00_00_F1_SE_CS_SP_PS_S5PRR_S00EN.csv 18 */
/* CLASS_FGHSF-FFSS33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNM-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-SMLM33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-MMLM00-S : protocol_G----_0021_C18_F1_SE_CS_SP_S5PRR_S0Y.csv 10 */
/* CLASS_FGHNF-FFMM00-S : protocol_H----_011_C07_F1_PI_AE_OS_S1U.csv 51 */
/* CLASS_FGUSM-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-SMLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSF-FFSM21-S : protocol_G-E--_208_C18--C_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPF-FFMF32-D : protocol_H----_011_C18_F1_PI_SE_SP_S2S.csv 13 */
/* CLASS_FHUNM-FFMM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y.csv 2 */
/* CLASS_FGUSM-FFMM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFMS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FUUPM-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUPS-FFLF32-D : protocol_G----_402_C05_02_F1_SE_CS_SP_PS_RG_S04AN.csv 6 */
/* CLASS_FGHSF-FFMS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUPF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 14 */
/* CLASS_FHHNM-FFLF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUPS-FFSF21-D : protocol_G----_0031_gd5.csv 1 */
/* CLASS_FHHNM-FFMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFMM32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 36 */
/* CLASS_FGHSM-FMLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FFMM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUPS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-MMLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFMM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUPM-FFLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHSF-FFSM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FUUNF-FFSF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFSM00-S : protocol_G----_406_C05_02_F1_SE_CS_SP_PS_RG_S04AI.csv 28 */
/* CLASS_FGHSS-SSLM33-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 1 */
/* CLASS_FUUNF-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-SMLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUNF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSM-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S038I.csv 8 */
/* CLASS_FGHSF-FSLS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFMF32-S : protocol_G-E--_300_C01_F1_SE_CS_SP_S0Y.csv 17 */
/* CLASS_FHHNF-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNM-FFMF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFSS22-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2S.csv 1 */
/* CLASS_FHHNM-FFMF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHPF-FFLM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFMM31-M : protocol_G-E--_107_C37_SOS_F1_PI_AE_Q4_CS_SP_PS_S0Y.csv 267 */
/* CLASS_FHHSF-FFMM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 18 */
/* CLASS_FGUSF-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNM-FFMF11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPF-FFSF32-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 5 */
/* CLASS_FUHPF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FHHNM-FFMM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSF-FFMF32-M : protocol_G-E--_208_C18CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUPM-FFMF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-SMLM21-S : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 9 */
/* CLASS_FGHSM-FFLM33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPM-FFSF21-D : protocol_G-E--_208_C18C--_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 16 */
/* CLASS_FUUPF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNF-FFMS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFMF32-S : protocol_G-E--_208_C18_F1_SE_CS_SOS_SP_PS_S5PRR_RG_S04AN.csv 21 */
/* CLASS_FUUPS-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S04AN.csv 11 */
/* CLASS_FGHSF-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMS31-S : protocol_G-E--_207_C01_F1_SE_CS_SP_PI_S5PRR_S0Y.csv 26 */
/* CLASS_FUUPM-FFSS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FSMS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNS-FFMS21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUPF-SSLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHNF-FFMF11-S : protocol_G-E--_208_C47_F1_SE_CS_SP_PS_S0Y.csv 52 */
/* CLASS_FHHNM-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-SMLM21-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 20 */
/* CLASS_FHHNF-FFMM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 30 */
/* CLASS_FGHNF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUNF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPM-FFMF31-M : protocol_G-E--_012_C18_F1_PI_AE_Q4_CS_SP_PS_S0Y.csv 5 */
/* CLASS_FGHNS-FFMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGUSF-FFMS32-S : protocol_G-E--_208_B07_F1_S5PRR_SE_CS_SP_PS_S0Y.csv 4 */
/* CLASS_FGHNF-FFMF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 13 */
/* CLASS_FHUSF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUPM-FFSM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFMF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FFMF11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUPM-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 4 */
/* CLASS_FGHNF-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSS-FFMS33-S : protocol_G-E--_211_C18_F1_AE_CS_SP_S0Y.csv 8 */
/* CLASS_FGUSM-SSLS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FFSM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHNF-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUNM-FFMF21-S : protocol_G-E--_110_C45_F1_PI_SE_CS_SP_PS_S4S.csv 5 */
/* CLASS_FGHSM-FFLS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFLS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNM-FFMF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHSF-FFSM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNF-FFSM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 12 */
/* CLASS_FGHSM-FFLS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FFSM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNM-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 2 */
/* CLASS_FHUSS-FFSS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFSF22-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 46 */
/* CLASS_FGUNF-FSMF11-S : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 3 */
/* CLASS_FGHNF-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSS-FSLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FUUPS-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUNF-FFMM32-M : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S00I.csv 2 */
/* CLASS_FUHNS-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FSLM32-M : protocol_G-E--_208_B07_F1_S5PRR_SE_CS_SP_PS_S0Y.csv 37 */
/* CLASS_FGHSS-FSLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHPM-FFSF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSLF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 2 */
/* CLASS_FGHSS-FSLM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNM-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNM-SMLM31-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 50 */
/* CLASS_FGUSM-FFMF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FSLM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNM-FFMM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUHNS-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNM-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFSS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUHNF-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNM-FSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFMF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSM-FFMF21-M : protocol_G-E--_100_C18_F1_PI_AE_Q4_CS_SP_PS_S0Y.csv 29 */
/* CLASS_FHUPM-FFSF21-M : protocol_G----_X1276__C12_02_nc_F1_AE_CS_SP_S5PRR_S2S.csv 53 */
/* CLASS_FGUNF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 27 */
/* CLASS_FGHSM-FFMF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 35 */
/* CLASS_FGHNF-FFMF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 4 */
/* CLASS_FUUPM-FFSF22-D : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 6 */
/* CLASS_FGHSM-FFMF31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 12 */
/* CLASS_FGUSF-FFSS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNF-FSLF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 29 */
/* CLASS_FGHSM-SMLM32-D : protocol_G-E--_200_C41_F1_AE_CS_SP_PI_S0Y.csv 150 */
/* CLASS_FGUPF-FFSM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 12 */
/* CLASS_FGUNF-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-SSLM00-S : protocol_G----_Z1410__C12_02_nc_F1_AE_CS_SP_S2S.csv 1 */
/* CLASS_FGUNF-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSS-FFMF32-S : protocol_G-E--_208_B07_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 25 */
/* CLASS_FGHSS-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSF-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGUNF-FFSM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGHSM-FFMM33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-SMLS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-SSLM11-S : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_PS_S0S.csv 1 */
/* CLASS_FGHSS-FFMF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSF-FSMM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FSMS11-S : protocol_G-E--_107_C45_F1_PI_AE_Q7_CS_SP_PS_S0Y.csv 6 */
/* CLASS_FGHSS-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FUUPM-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUSF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FSLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSM-FFSF22-M : protocol_H----_047_C45_F1_AE_R8_CS_SP_S2S.csv 12 */
/* CLASS_FHUNF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 25 */
/* CLASS_FGUNF-FFSM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPM-FFLM33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-SSLM33-S : protocol_G-E--_092_C01_F1_AE_CS_SP_PS_CO_S0Y.csv 1 */
/* CLASS_FGHSM-FMLS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFLS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUNF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGUSF-FFSS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUPM-FFLM33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFSF11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 2 */
/* CLASS_FGUNF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 21 */
/* CLASS_FGHSS-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FGHNM-FSLF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUNF-FSLS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMF11-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 15 */
/* CLASS_FGHSF-FFMM31-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 13 */
/* CLASS_FGHSS-FFMF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FSLS31-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHHSF-FMLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHPF-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFMF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNF-FFSS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FFMM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSF-FSLM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUHPF-FFSF22-D : protocol_G-E--_208_C18_F2_SE_CS_SP_PS_S5PRR_RG_S04A.csv 2 */
/* CLASS_FGUNF-FFMS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNS-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FSLM32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FUHPF-FFSF22-M : protocol_G-E--_209_C18_F1_AE_CS_SP_PI_S0Y.csv 1 */
/* CLASS_FUUPF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSF-FFMM31-S : protocol_G-E--_208_C18C--_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 40 */
/* CLASS_FGUPM-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 2 */
/* CLASS_FGHSF-SMLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-FFMS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSF-FSLF32-M : protocol_G-E--_107_C36_F1_PI_AE_Q4_CS_SP_PS_S0Y.csv 23 */
/* CLASS_FGHSM-FFLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSM-FFMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFLM32-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 2 */
/* CLASS_FHUSS-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-SSLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FHUSS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUPF-FFSF22-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FGUSS-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNM-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFMM32-M : protocol_G-E--_300_C18_F1_URBAN_S0Y.csv 15 */
/* CLASS_FHUPF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FSLM32-M : protocol_G-E--_208_C02AMC_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSF-SMLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGHNF-FSLF31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUPF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FSMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHHNF-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSM-FSLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 85 */
/* CLASS_FHHNM-SSLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 51 */
/* CLASS_FGHSS-FFMS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 17 */
/* CLASS_FGHSM-FMLM32-D : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FGHNF-SMLF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSM-FSLS32-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S0Y.csv 1 */
/* CLASS_FGHSS-FFMS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FHHNF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 13 */
/* CLASS_FGHSM-FMLM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 6 */
/* CLASS_FHHNF-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-SMLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFLF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 6 */
/* CLASS_FUUPS-FFSF22-D : protocol_G----_Z1014__C12_02_nc_F1_AE_CS_SP_S2S.csv 36 */
/* CLASS_FGHNF-FMLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSF-FFMM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 23 */
/* CLASS_FGHSS-SMLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUPM-FFSF21-M : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 11 */
/* CLASS_FGUSM-FSLM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FMLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSM-FFMM31-S : protocol_G----_0021_10gd3.csv 1 */
/* CLASS_FGHSF-FFMF33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FSLM33-M : protocol_G-E--_300_C18_F1_SE_CS_SP_PS_S0Y.csv 18 */
/* CLASS_FGHNF-SMLF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FSLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUSF-FFSF22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSM-FFMF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 28 */
/* CLASS_FGUSF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUPM-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUPM-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUPM-FFSF21-D : protocol_G----_X1276__C12_02_nc_F1_AE_CS_SP_S5PRR_S2S.csv 23 */
/* CLASS_FGHSM-FFLS33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGUPM-FFSS22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFSS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSS-SMLM00-S : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 3 */
/* CLASS_FGUSF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUSF-FSLM33-M : protocol_G-E--_107_B03_F1_PI_AE_Q4_CS_SP_PS_S0Y.csv 1 */
/* CLASS_FHHSM-FFMM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-SSLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUPM-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 5 */
/* CLASS_FGUSF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFMS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGHSM-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNS-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 2 */
/* CLASS_FGUNF-SMLS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSM-FSMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FHHSF-FMLM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHSF-FFMM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 13 */
/* CLASS_FGUSM-FFMF32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S00I.csv 2 */
/* CLASS_FGUNF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 25 */
/* CLASS_FUHNS-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPF-FSLM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUNF-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUPF-FSLM22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNM-SSLM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFMM00-S : protocol_G-E--_207_C18_F1_AE_CS_SP_PS_S3S.csv 20 */
/* CLASS_FGUNM-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUHNF-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSS-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHPM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUSM-FFMF31-M : protocol_H----_042_B03_F1_AE_Q4_SP_S2S.csv 2 */
/* CLASS_FGUNS-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUSF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFSM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FSLS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FSLF11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNF-FFMF11-S : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 11 */
/* CLASS_FGHSS-SSLM31-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 4 */
/* CLASS_FGUNF-FSLS32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 3 */
/* CLASS_FGUSS-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FSLM32-D : protocol_G-E--_301_C18_F1_URBAN_S5PRR_S0Y.csv 228 */
/* CLASS_FGHNF-FSLF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 18 */
/* CLASS_FGHPS-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 1 */
/* CLASS_FHUPM-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUSM-FFMM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHNS-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 11 */
/* CLASS_FGUNF-FFSS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 29 */
/* CLASS_FGHSF-SSLF00-S : protocol_G-E--_208_C47_F1_SE_CS_SP_PS_S0Y.csv 4 */
/* CLASS_FGHSF-FFMS21-M : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_S0e.csv 5 */
/* CLASS_FGHNF-FFMM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S2mI.csv 45 */
/* CLASS_FGHSS-FFMF33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPS-FFSF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNF-FMLF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNS-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFMF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSM-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUSF-FFSM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFSM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSM-SMLM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S2g.csv 51 */
/* CLASS_FGHNF-FSLS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHPF-FFSF11-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHPF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FSMM31-S : protocol_G-E--_208_C18C--_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FUUPF-FFSM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNS-FFMM00-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 6 */
/* CLASS_FGHSF-FFSM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSF-FFSS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FHUSM-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 9 */
/* CLASS_FGUNF-FFMS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNF-FFMM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNS-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNF-FFSF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHNS-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUPS-FFMM32-S : protocol_G-E--_024_B31_F1_PI_AE_Q4_CS_SP_S2S.csv 5 */
/* CLASS_FGHSM-FSMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGUPF-SSLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFMM33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNF-FFSS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFMM11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGHPF-FFLM21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUNF-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUNM-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNM-FFMS22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FFSF11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSM-FFSM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-FFSS22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FGHPF-FFLM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSS22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHPF-FFLM22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNM-FFMS22-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-FFMS21-S : protocol_G-E--_208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN.csv 69 */
/* CLASS_FGHSM-FSLM32-S : protocol_208_C09_12_F1_SE_CS_SP_PS_S070I.csv 16 */
/* CLASS_FGHSM-FSMM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FFLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNS-FSMF11-S : protocol_G-E--_208_C47_F1_SE_CS_SP_PS_S0Y.csv 5 */
/* CLASS_FHUSM-FFMS21-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 2 */
/* CLASS_FGHNF-FSLM33-S : protocol_G-E--_107_C41_F1_PI_AE_Q4_CS_SP_PS_S4S.csv 54 */
/* CLASS_FGUPS-FFMF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-FSLM21-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 2 */
/* CLASS_FHHSS-FFMS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFSS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUSM-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPS-FFSS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-SMLF00-S : protocol_C12_02_nc_SAT001_MinMin_p005000_rr.csv 34 */
/* CLASS_FUUPF-FFSM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FSMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHNF-FSLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSF-FFMF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSM-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUNF-FFSM00-S : protocol_G-E--_207_C18_F1_AE_CS_SP_PS_S0Y.csv 6 */
/* CLASS_FUUPF-FFSF22-D : protocol_G-E--_209_C18_F1_AE_CS_SP_PI_S0Y.csv 21 */
/* CLASS_FGHNF-FSLF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 13 */
/* CLASS_FUUPS-FFSF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUNS-FFMF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPF-FFSF22-M : protocol_G-E--_209_C18_F1_AE_CS_SP_PI_S0Y.csv 16 */
/* CLASS_FGHNF-FMLM00-S : protocol_G-E--_208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHNF-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSM-FSLM33-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FGUNM-FFMM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUPS-FFSF32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPM-FFSF31-M : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 6 */
/* CLASS_FHHSF-FFSF11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHUSM-FFSS22-S : protocol_G-E--_208_C18C--_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FGHNF-FFMS32-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 11 */
/* CLASS_FGUNF-FFMF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 9 */
/* CLASS_FGHNF-FFMS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFMM32-S : protocol_G-E--_301_C18_F1_URBAN_S5PRR_RG_S0Y.csv 24 */
/* CLASS_FGHNF-FMLS31-S : protocol_G-E--_208_B07CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FGHSF-FSLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PI_PS_S5PRR_S032N.csv 69 */
/* CLASS_FGUSM-FFMF22-M : protocol_G-E--_300_C18_F1_SE_CS_SP_PS_S0Y.csv 1 */
/* CLASS_FGHNS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FGHSM-FFMM31-S : protocol_C07_19_nc_SOS_SAT001_MinMin_p005000_rr.csv 92 */
/* CLASS_FGHSM-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNM-FFMS21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNM-FFMS22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGHSM-SMLM31-M : protocol_C07_19_nc_SAT001_MinMin_p005000_rr.csv 114 */
/* CLASS_FGUNM-FFMS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN.csv 1 */
/* CLASS_FGHSM-FFMM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHNF-FMLS32-S : protocol_G-E--_207_C18_F1_AE_Q7_CS_SP_CO_PS_S00.csv 1 */
/* CLASS_FGHSM-SMLM31-D : protocol_C07_19_nc_SOS_SAT001_MinMin_p005000_rr.csv 11 */
/* CLASS_FHUSF-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FUHPM-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUNF-SMLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FUUPF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFMS31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FGHSM-SMLF33-S : protocol_SAT001_MinMin_p005000_rr_RG.csv 3 */
/* CLASS_FUUPM-FSLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHUSS-FFSM22-S : protocol_G----_0010_evo.csv 2 */
/* CLASS_FGUNM-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSF-MMLM11-S : protocol_G----_0010_evo.csv 3 */
/* CLASS_FGHNF-FFSM31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-SSLM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSF-FFMM21-M : protocol_G----_429_C05_02_F1_SE_CS_SP_PS_RG_S04AI.csv 99 */
/* CLASS_FUUPF-FFSF21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 50 */
/* CLASS_FGUNF-FFMM11-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI.csv 1 */
/* CLASS_FHHNM-FFMM21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FGHSF-FFSS21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 15 */
/* CLASS_FGHSF-FFMM00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 20 */
/* CLASS_FGUPF-SSLM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSS-FFMM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 1 */
/* CLASS_FGHSM-FSLF32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSM-FFMS22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHUSM-FFSS21-D : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_PS_S0S.csv 2 */
/* CLASS_FUUPM-FFSF21-M : protocol_H----_047_C09_12_F1_AE_ND_CS_SP_S5PRR_S2S.csv 219 */
/* CLASS_FGHSM-FSLM33-S : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 1 */
/* CLASS_FUUPM-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 10 */
/* CLASS_FHHSF-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUNF-FSLM32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFSF21-S : protocol_U----_102_C09_12_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 114 */
/* CLASS_FGUNM-FFMF22-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 6 */
/* CLASS_FHUNS-FFSF31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFMM31-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FSLM33-D : protocol_G-E--_200_B02_F1_SE_CS_SP_PI_S2k.csv 49 */
/* CLASS_FGUNF-FSLF11-S : protocol_G-E--_208_B07CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 8 */
/* CLASS_FHUNS-FFSS11-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPF-SSLM33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSS-FFSS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSM-SSLM32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFMS21-S : protocol_U----_115v_C12_07_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN.csv 12 */
/* CLASS_FGUNF-FSMM33-S : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2S.csv 1 */
/* CLASS_FHUPM-FFMF32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 2 */
/* CLASS_FGHSM-FFMS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSM-FFMS31-S : protocol_G-E--_302_C18_F1_URBAN_S5PRR_RG_S04BN.csv 10 */
/* CLASS_FGHSM-FSLM32-M : protocol_G-E--_207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S0Y.csv 112 */
/* CLASS_FGHNS-FFMS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSM-FFMS21-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FGHSS-FFSS32-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FGUNM-FFSS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-SMLF33-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S032N.csv 5 */
/* CLASS_FHUSF-FFSS31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGUSF-FFSF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FHHSM-FSLM31-M : protocol_G-E--_207_C18_F1_AE_CS_SP_PS_S0Y.csv 3 */
/* CLASS_FGHSF-FSLS32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FUUPF-FFSS32-D : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUSF-FFSF22-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHNF-FFMS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 3 */
/* CLASS_FHHPM-FFSS21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FUUPM-FFMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 16 */
/* CLASS_FHUSF-FFSS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHSF-FSLF00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_S4d.csv 1 */
/* CLASS_FGHNF-FSLF21-S : protocol_G-E--_200_B02_F1_SE_CS_SP_PI_S2k.csv 6 */
/* CLASS_FGHNF-FFMM11-M : protocol_G-E--_208_B07CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 4 */
/* CLASS_FHUSS-FFMM32-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 2 */
/* CLASS_FGHNF-SSLS11-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 0 */
/* CLASS_FHHSS-FFMM33-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFMM31-S : protocol_G-E--_207_C18_F1_AE_CS_SP_PI_PS_S0S.csv 8 */
/* CLASS_FHHSS-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSS-FFMM31-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 5 */
/* CLASS_FUHNM-FFSF21-M : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGUSF-SMLS00-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHHSM-FFMF21-M : protocol_G-E--_200_B02_F1_AE_CS_SP_PI_S0Y.csv 4 */
/* CLASS_FUHSM-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FGHSF-FSLS32-S : protocol_G-E--_303_C18_F1_URBAN_S0Y.csv 6 */
/* CLASS_FGUSF-FFMM21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 23 */
/* CLASS_FHHSS-FFSF21-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 7 */
/* CLASS_FHHSF-FFSS31-S : protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv 1 */
/* CLASS_FHUPS-FFSS22-M : protocol_G----_0029_C18_F1_PI_SE_CS_SP_S0Y.csv 1 */
#ifdef CHE_PROOFCONTROL_INTERNAL
/* Strategies used: */
"G_____406_C05_02_F1_SE_CS_SP_PS_RG_S04AI = \n"
"(10.Clauseweight(PreferGoals,1,1,1),"
" 10.Clauseweight(PreferNonGoals,1,1,1),"
" 10.Clauseweight(ByHornDist,1,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___207_C01_F1_SE_CS_SP_PI_S5PRR_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___012_C18_F1_PI_AE_Q4_CS_SP_PS_S0Y = \n"
"(7.ConjectureRelativeSymbolWeight(ConstPrio,0.5,100,100,100,100,1.5,1.5,1),"
" 3.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___200_B02_F1_AE_CS_SP_PI_S2k = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 6.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 8.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___301_C18_F1_URBAN_S5PRR_RG_S04BN = \n"
"(1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(SimulateSOS,1),"
" 1.SymbolTypeweight(DeferSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(SimulateSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"G_E___303_C18_F1_URBAN_S0Y = \n"
"(1.ConjectureTermPrefixWeight(ConstPrio,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(ConstPrio,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(ConstPrio,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(ConstPrio,1),"
" 1.SymbolTypeweight(ConstPrio,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(ConstPrio,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(ConstPrio,2))\n"
"G_E___200_B02_F1_SE_CS_SP_PI_S0S = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 6.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 8.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___092_C01_F1_AE_CS_SP_PS_CO_S0Y = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,1,2,0,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___200_C45_F1_SE_CS_SP_PI_CO_S5PRR_S0V = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 6.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 8.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___208_C02____F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___300_C01_S5PRR_S00 = \n"
"(1.ConjectureGeneralSymbolWeight(SimulateSOS,488,104,105,32,173,0,327,3.63456933832,1.43436931217,1),"
" 1.FIFOWeight(PreferProcessed),"
" 8.Clauseweight(PreferUnitGroundGoals,1,1,0.492432663985),"
" 3.Refinedweight(PreferGoals,2,4,7,4.94895515161,6.55154057122),"
" 2.ConjectureRelativeSymbolWeight(ConstPrio,0.0640406356983,67,160,111,25,3.13817216288,2.75641029012,1))\n"
"C07_19_nc_SAT001_MinMin_rr = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___200_B02_F1_SE_CS_SP_PI_S2k = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 6.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 8.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___215_C46_F1_AE_CS_SP_PS_S2S = \n"
"(10.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(ConstPrio))\n"
"C12_02_nc_SAT001_MinMin_rr = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"U_____206d_05_C11_08_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(5.DAGweight(PreferNonGoals,2,1,1,5,true,false,false,true,true,true,false),"
" 5.DAGweight(SimulateSOS,1,2,1,5,true,true,true,true,false,false,false),"
" 1.FIFOWeight(ConstPrio))\n"
"G_____404_C05_02_F1_SE_CS_SP_PS_RG_S04AN = \n"
"(5.Clauseweight(PreferGoals,1,1,1),"
" 20.Clauseweight(PreferNonGoals,1,1,1),"
" 5.Clauseweight(ByHornDist,1,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___107_B03_F1_PI_AE_Q4_CS_SP_PS_S0Y = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___207_C18_F1_SP_PI_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___107_B42_F1_PI_SE_Q4_CS_SP_PS_S5PRR_S0Y = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18__C_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___107_C45_F1_PI_AE_Q7_CS_SP_PS_S0Y = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___060_C18_F1_PI_SE_CS_SP_CO_S0Y = \n"
"(1.RelevanceLevelWeight(ConstPrio,2,2,0,2,100,100,100,100,1.5,1.5,1))\n"
"H_____042_B03_F1_AE_Q4_SP_S2S = \n"
"(10.Refinedweight(PreferGoals,1,2,2,2,0.5),"
" 10.Refinedweight(PreferNonGoals,2,1,2,2,2),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"U_____102_C09_12_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(5.PNRefinedweight(PreferGoals,1,1,1,2,2,2,0.5),"
" 10.PNRefinedweight(PreferNonGoals,2,1,1,1,2,2,2),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 4.Diversityweight(ConstPrio,1,1,1.5,1,1,-1.000000,0.000000,1.000000,1.000000))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_____0031_gd5 = \n"
"(1.ConjectureGeneralSymbolWeight(ConstPrio,3,3,3,1,1,1,4,1,1,1))\n"
"G_E___200_C45_F1_AE_CS_SP_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 6.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 8.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"H_____011_C07_F1_PI_SE_SP_S0V = \n"
"(8.Refinedweight(PreferGoals,1,2,2,1,0.8),"
" 8.Refinedweight(PreferNonGoals,2,1,2,3,0.8),"
" 1.Clauseweight(ConstPrio,1,1,0.7),"
" 1.FIFOWeight(ByNegLitDist))\n"
"G_E___301_C18_F1_URBAN_S5PRR_RG_S0Y = \n"
"(1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(SimulateSOS,1),"
" 1.SymbolTypeweight(DeferSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(SimulateSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S2mI = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_B07_F1_SE_CS_SP_PS_S4d = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SOS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2S = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___107_C36_F1_PI_AE_Q4_CS_SP_PS_S0Y = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___300_C01_F1_SE_CS_SP_S0Y = \n"
"(1.ConjectureGeneralSymbolWeight(SimulateSOS,488,104,105,32,173,0,327,3.63456933832,1.43436931217,1),"
" 1.FIFOWeight(PreferProcessed),"
" 8.Clauseweight(PreferUnitGroundGoals,1,1,0.492432663985),"
" 3.Refinedweight(PreferGoals,2,4,7,4.94895515161,6.55154057122),"
" 2.ConjectureRelativeSymbolWeight(ConstPrio,0.0640406356983,67,160,111,25,3.13817216288,2.75641029012,1))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_____0021_C18_F1_SE_CS_SP_S5PRR_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(ConstPrio,0.07,3,6,4,1,1,1,1))\n"
"G_E___207_C18_F1_AE_CS_SP_PS_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___200_C41_F1_AE_CS_SP_PI_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 6.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 8.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S032N = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___300_C18_F1_SE_CS_SP_PS_S0Y = \n"
"(1.ConjectureGeneralSymbolWeight(SimulateSOS,488,104,105,32,173,0,327,3.63456933832,1.43436931217,1),"
" 1.FIFOWeight(PreferProcessed),"
" 8.Clauseweight(PreferUnitGroundGoals,1,1,0.492432663985),"
" 3.Refinedweight(PreferGoals,2,4,7,4.94895515161,6.55154057122),"
" 2.ConjectureRelativeSymbolWeight(ConstPrio,0.0640406356983,67,160,111,25,3.13817216288,2.75641029012,1))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_B07_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___209_C18_F1_AE_CS_SP_PI_S0Y = \n"
"(3.rweight21_a,1.rweight21_g)\n"
"G_E___110_C45_F1_PI_SE_CS_SP_PS_S4S = \n"
"(4.RelevanceLevelWeight2(PreferGoals,1,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.RelevanceLevelWeight2(PreferNonGoals,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___302_C18_F1_URBAN_RG_S04BN = \n"
"(1.ConjectureTermPrefixWeight(ConstPrio,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(SimulateSOS,1),"
" 1.SymbolTypeweight(SimulateSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(SimulateSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"G_E___207_C18_F1_AE_Q7_CS_SP_CO_PS_S00 = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___208_C18CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_____X1276__C12_02_nc_F1_AE_CS_SP_S5PRR_S2S = \n"
"(20.Diversityweight(ConstPrio,1,1,1.5,1,1,-1.000000,0.000000,-1.000000,2.000000),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___207_C18_F1_AE_CS_SP_PI_S0e = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"H_____102_C18_F1_PI_AE_CS_SP_PS_S2S = \n"
"(10.Refinedweight(PreferGoals,1,2,2,2,0.5),"
" 10.Refinedweight(PreferNonGoals,2,1,2,2,2),"
" 3.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 2.ClauseWeightAge(ConstPrio,1,1,1,3))\n"
"G_E___107_B00_00_F1_PI_AE_Q4_CS_SP_PS_S071I = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_____402_C05_02_F1_SE_CS_SP_PS_RG_S04AN = \n"
"(1.Clauseweight(PreferGoals,1,1,1),"
" 1.Clauseweight(PreferNonGoals,1,1,1),"
" 28.Clauseweight(ByHornDist,1,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___207_C18_F1_SE_CS_SP_PI_PS_S2SA = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S4b = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F1_AE_CS_SP_PS_S3S = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"h208_C09_12_F1_SE_CS_SP_PS_S070I = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"U_____206e_02_C10_23_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(5.DAGweight(PreferNonGoals,2,1,1,2,true,true,true,true,false,false,false),"
" 5.DAGweight(SimulateSOS,1,2,1,2,true,true,true,true,false,false,false),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___207_C18_F1_AE_CS_SP_PI_PS_S2U = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S4d = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AI = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C47_F1_SE_CS_SP_PS_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S05BN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PI_PS_S5PRR_S032N = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C02CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___302_C18_F1_URBAN_S0Y = \n"
"(1.ConjectureTermPrefixWeight(ConstPrio,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(SimulateSOS,1),"
" 1.SymbolTypeweight(SimulateSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(SimulateSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"G_E___100_C18_F1_PI_AE_Q4_CS_SP_PS_S0Y = \n"
"(10.RelevanceLevelWeight2(SimulateSOS,1,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_____0019_C18_F1_PI_SE_CS_SP_S0Y = \n"
"(1.ConjectureGeneralSymbolWeight(ConstPrio,1,1,1,3,3,3,0,1,1,1))\n"
"G_E___212_C18_F1_AE_Q12_CS_SP_S2S = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,1,2,0,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___107_B42_F1_PI_SE_Q4_CS_SP_PS_S0YI = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___207_C18_F1_AE_CS_SP_PS_S3S = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___024_B31_F1_PI_AE_Q4_CS_SP_S2S = \n"
"(4.ConjectureGeneralSymbolWeight(SimulateSOS,100,100,100,50,50,50,50,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,100,100,100,50,50,1000,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___200_B02_F1_AE_CS_SP_PI_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 6.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 8.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"SAT001_MinMin_NN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"H_____047_C45_F1_AE_R8_CS_SP_S2S = \n"
"(10.PNRefinedweight(PreferGoals,1,1,1,2,2,2,0.5),"
" 10.PNRefinedweight(PreferNonGoals,2,1,1,1,2,2,2),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_____429_C05_02_F1_SE_CS_SP_PS_RG_S04AI = \n"
"(14.Clauseweight(PreferGoals,1,1,1),"
" 14.Clauseweight(PreferNonGoals,1,1,1),"
" 2.Clauseweight(ByHornDist,1,1,1),"
" 1.FIFOWeight(ByHornDist))\n"
"G_E___300_C18_F1_URBAN_S0Y = \n"
"(1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(DeferSOS,1),"
" 1.SymbolTypeweight(DeferSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(DeferSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S00 = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___302_C18_F1_URBAN_S5PRR_RG_S0Y = \n"
"(1.ConjectureTermPrefixWeight(ConstPrio,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(SimulateSOS,1),"
" 1.SymbolTypeweight(SimulateSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(SimulateSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"G_E___208_B00_00_F1_SE_CS_SP_PS_S5PRR_S00EN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___207_C18_F1_SE_CS_SP_PI_PS_S00I = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S2v = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S3b = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"U_____115v_C12_07_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(10.Clauseweight(PreferGoals,1,1,1),"
" 10.ConjectureRelativeSymbolWeight(PreferNonGoals,0.7,2,1,1,1,2,1,1),"
" 10.Refinedweight(PreferNonGoals,1,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_____0029_C18_F1_PI_SE_CS_SP_S0Y = \n"
"(1.Clauseweight(ConstPrio,1,1,2))\n"
"G_E___208_C02AMC_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_____Z1410__C12_02_nc_F1_AE_CS_SP_S2S = \n"
"(20.Diversityweight(SimulateSOS,1,1,1.5,1,1,1.000000,0.000000,1.000000,0.000000),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___006_C18_F1_PI_AE_Q4_CS_SP_S2S = \n"
"(10.ConjectureRelativeSymbolWeight(ConstPrio,0.5,100,100,100,50,1.5,1.5,1.5),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___107_C41_F1_PI_AE_Q4_CS_SP_PS_S4S = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"H_____011_C18_F1_PI_SE_SP_S2S = \n"
"(8.Refinedweight(PreferGoals,1,2,2,1,0.8),"
" 8.Refinedweight(PreferNonGoals,2,1,2,3,0.8),"
" 1.Clauseweight(ConstPrio,1,1,0.7),"
" 1.FIFOWeight(ByNegLitDist))\n"
"G_N___023_B07_F1_SP_PI_Q7_CS_SP_CO_S5PRR_S0Y = \n"
"(12.Clauseweight(ConstPrio,3,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___301_C18_F1_URBAN_S5PRR_S0Y = \n"
"(1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(SimulateSOS,1),"
" 1.SymbolTypeweight(DeferSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(SimulateSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"G_E___107_C37_SOS_F1_PI_AE_Q4_CS_SP_PS_S0Y = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"U_____043_B31_F1_PI_AE_CS_SP_S2S = \n"
"(4.PNRefinedweight(PreferNonGoals,4,5,5,4,2,1,1),"
" 8.PNRefinedweight(PreferGoals,5,2,2,5,2,1,0.5),"
" 1.FIFOWeight(ConstPrio))\n"
"SAT001_MinMin_rr_RG = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"U_____206d_00_C11_23_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(5.DAGweight(PreferNonGoals,2,1,1,0,true,false,false,true,true,true,false),"
" 5.DAGweight(SimulateSOS,1,2,1,0,true,true,true,true,false,false,false),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___207_C18_F1_AE_CS_SP_PI_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___208_C18_SOS_F1_SE_CS_SP_PS_S4c = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S2g = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___207_C18_F1_AE_CS_SP_PI_PS_S0S = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
"G_E___107_C48_F1_PI_AE_Q4_CS_SP_PS_S0Y = \n"
"(4.RelevanceLevelWeight2(SimulateSOS,0,2,1,2,100,100,100,400,1.5,1.5,1),"
" 3.ConjectureGeneralSymbolWeight(PreferNonGoals,200,100,200,50,50,1,100,1.5,1.5,1),"
" 1.Clauseweight(PreferProcessed,1,1,1),"
" 1.FIFOWeight(PreferProcessed))\n"
"G_E___208_C18C___F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_____0021_10gd3 = \n"
"(1.ConjectureRelativeSymbolWeight(ConstPrio,0.07,3,6,4,1,1,1,1))\n"
"G_E___208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_____0010_evo = \n"
"(1.ConjectureGeneralSymbolWeight(SimulateSOS,488,104,105,32,173,0,327,3.63456933832,1.43436931217,1),"
" 1.FIFOWeight(PreferProcessed),"
" 8.Clauseweight(PreferUnitGroundGoals,1,1,0.492432663985),"
" 3.Refinedweight(PreferGoals,2,4,7,4.94895515161,6.55154057122),"
" 2.ConjectureRelativeSymbolWeight(ConstPrio,0.0640406356983,67,160,111,25,3.13817216288,2.75641029012,1))\n"
"H_____047_C09_12_F1_AE_ND_CS_SP_S5PRR_S2S = \n"
"(10.PNRefinedweight(PreferGoals,1,1,1,2,2,2,0.5),"
" 10.PNRefinedweight(PreferNonGoals,2,1,1,1,2,2,2),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_____Z1014__C12_02_nc_F1_AE_CS_SP_S2S = \n"
"(10.Diversityweight(SimulateSOS,1,1,1.5,1,1,-1.000000,-1.000000,2.000000,0.000000),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___208_B07_F1_S5PRR_SE_CS_SP_PS_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"H_____011_C07_F1_PI_AE_Q4_CS_SP_PS_S0V = \n"
"(8.Refinedweight(PreferGoals,1,2,2,1,0.8),"
" 8.Refinedweight(PreferNonGoals,2,1,2,3,0.8),"
" 1.Clauseweight(ConstPrio,1,1,0.7),"
" 1.FIFOWeight(ByNegLitDist))\n"
"G_E___008_C45_F1_PI_SE_Q4_CS_SP_S4SI = \n"
"(10.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___302_C18_F1_URBAN_S5PRR_RG_S04BN = \n"
"(1.ConjectureTermPrefixWeight(ConstPrio,1,3,0.1,5,0,0.1,1,4),"
" 1.ConjectureTermPrefixWeight(DeferSOS,1,3,0.5,100,0,0.2,0.2,4),"
" 1.Refinedweight(ConstPrio,4,300,4,4,0.7),"
" 1.RelevanceLevelWeight2(PreferProcessed,0,1,2,1,1,1,200,200,2.5,9999.9,9999.9),"
" 1.StaggeredWeight(SimulateSOS,1),"
" 1.SymbolTypeweight(SimulateSOS,18,7,-2,5,9999.9,2,1.5),"
" 2.Clauseweight(ConstPrio,20,9999,4),"
" 2.ConjectureSymbolWeight(SimulateSOS,9999,20,50,-1,50,3,3,0.5),"
" 2.StaggeredWeight(DeferSOS,2))\n"
"H_____047_B31_F1_PI_AE_R4_CS_SP_S4c = \n"
"(10.PNRefinedweight(PreferGoals,1,1,1,2,2,2,0.5),"
" 10.PNRefinedweight(PreferNonGoals,2,1,1,1,2,2,2),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S038I = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___208_C18_F2_SE_CS_SP_PS_S5PRR_RG_S04A = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"C07_19_nc_SOS_SAT001_MinMin_rr = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"H_____011_C07_F1_PI_AE_OS_S1U = \n"
"(8.Refinedweight(PreferGoals,1,2,2,1,0.8),"
" 8.Refinedweight(PreferNonGoals,2,1,2,3,0.8),"
" 1.Clauseweight(ConstPrio,1,1,0.7),"
" 1.FIFOWeight(ByNegLitDist))\n"
"G_E___208_B07CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"H_____047_B31_F1_PI_AE_R4_CS_SP_S2S = \n"
"(10.PNRefinedweight(PreferGoals,1,1,1,2,2,2,0.5),"
" 10.PNRefinedweight(PreferNonGoals,2,1,1,1,2,2,2),"
" 5.OrientLMaxWeight(ConstPrio,2,1,2,1,1),"
" 1.FIFOWeight(ConstPrio))\n"
"G_E___208_C18_F1_SE_CS_SP_PS_S0Y_ni = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 1.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,3,2,2,1.5,2))\n"
"G_E___211_C18_F1_AE_CS_SP_S0Y = \n"
"(1.ConjectureRelativeSymbolWeight(SimulateSOS,0.5,100,100,100,100,1.5,1.5,1),"
" 4.ConjectureRelativeSymbolWeight(ConstPrio,0.1,100,100,100,100,1.5,1.5,1.5),"
" 2.FIFOWeight(PreferProcessed),"
" 1.ConjectureRelativeSymbolWeight(PreferNonGoals,0.5,100,100,100,100,1.5,1.5,1),"
" 4.Refinedweight(SimulateSOS,1,1,2,1.5,2))\n"
/* Global best, protocol_G-E--_208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN.csv, already defined */
#endif
#if defined(CHE_HEURISTICS_INTERNAL) || defined(TO_ORDERING_INTERNAL)
else if(
( /* CLASS_FGUNF-FMLF33-S Solved: 2 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSM00-S Solved: 28 of 29 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____406_C05_02_F1_SE_CS_SP_PS_RG_S04AI";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PInvArConstMin;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSF-FSLM31-M Solved: 102 of 118 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS31-S Solved: 26 of 46 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C01_F1_SE_CS_SP_PI_S5PRR_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
#endif
}
else if(
( /* CLASS_FUUPM-FFMF31-M Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___012_C18_F1_PI_AE_Q4_CS_SP_PS_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSM-FSLS31-M Solved: 35 of 54 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___200_B02_F1_AE_CS_SP_PI_S2k";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQArNTEqFirst;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PArity;
#endif
}
else if(
( /* CLASS_FGHSS-FFMM21-M Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___301_C18_F1_URBAN_S5PRR_RG_S04BN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptUniqMaxHorn;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSF-FSLS32-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___303_C18_F1_URBAN_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSM-FFMF21-M Solved: 12 of 17 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___200_B02_F1_SE_CS_SP_PI_S0S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexG;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PArity;
#endif
}
else if(
( /* CLASS_FGHSF-SSLF33-S Solved: 4 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SSLM33-S Solved: 1 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___092_C01_F1_AE_CS_SP_PS_CO_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.condensing=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
#endif
}
else if(
( /* CLASS_FGHSM-SSLM33-D Solved: 2 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMF21-S Solved: 6 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___200_C45_F1_SE_CS_SP_PI_CO_S5PRR_S0V";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptRRHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.condensing=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUPS-FFMM32-M Solved: 7 of 30 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C02____F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WConstantWeight;
oparms.to_prec_gen=PArity;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=10;
oparms.conj_axiom_mod=0;
oparms.axiom_only_mod=0;
#endif
}
else if(
( /* CLASS_FHUNM-FFSF22-M Solved: 4 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___300_C01_S5PRR_S00";
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
#endif
}
else if(
( /* CLASS_FHUSF-FFMM32-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-SMLM32-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM31-M Solved: 27 of 43 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM31-D Solved: 41 of 116 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHSS-FFMM21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-SMLM33-D Solved: 123 of 164 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSS21-S Solved: 13 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FMLM21-M Solved: 14 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM33-M Solved: 13 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMF31-S Solved: 27 of 46 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-SSLM33-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLM21-S Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLM21-M Solved: 20 of 22 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNM-SMLM31-M Solved: 50 of 53 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-SSLM31-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-SMLM31-M Solved: 114 of 147 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "C07_19_nc_SAT001_MinMin_rr";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FGHSM-SSLM33-M Solved: 80 of 95 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM33-D Solved: 49 of 148 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF21-S Solved: 6 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___200_B02_F1_SE_CS_SP_PI_S2k";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQArNTEqFirst;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PArity;
#endif
}
else if(
( /* CLASS_FGHSS-FFMM32-S Solved: 6 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___215_C46_F1_AE_CS_SP_PS_S2S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvConjFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-SMLF00-S Solved: 34 of 34 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "C12_02_nc_SAT001_MinMin_rr";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PByInvFreqHack;
#endif
}
else if(
( /* CLASS_FUUPS-FFSF22-M Solved: 33 of 41 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "U_____206d_05_C11_08_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.eqdef_incrlimit=LONG_MIN;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvArityMax0;
oparms.to_prec_gen=PByInvFreqConstMin;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSF-SMLM22-M Solved: 7 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____404_C05_02_F1_SE_CS_SP_PS_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PInvArConstMin;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGUNF-FSLS33-S Solved: 2 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF21-S Solved: 41 of 51 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMS32-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLM32-S Solved: 12 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMS31-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLF31-S Solved: 3 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLF31-M Solved: 2 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM32-S Solved: 36 of 36 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMF11-S Solved: 15 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FSLS32-S Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFMM00-S Solved: 6 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMS32-S Solved: 11 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMM11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2SI";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSF-FSLM33-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_B03_F1_PI_AE_Q4_CS_SP_PS_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PInvArity;
#endif
}
else if(
( /* CLASS_FGHNS-FFMF11-S Solved: 12 of 31 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_SP_PI_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUSM-FFSM32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_B42_F1_PI_SE_Q4_CS_SP_PS_S5PRR_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFreqConjMax;
#endif
}
else if(
( /* CLASS_FHUNF-FFMF00-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM31-M Solved: 79 of 196 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFLF00-S Solved: 11 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM21-M Solved: 23 of 27 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS21-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FSMF11-S Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMF11-S Solved: 11 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS21-S Solved: 69 of 103 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_S04BN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCNormal;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecedence;
oparms.to_prec_gen=PByInvFreqHack;
#endif
}
else if(
( /* CLASS_FGHSM-FSLS32-M Solved: 3 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS32-M Solved: 6 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18__C_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=00;
oparms.conj_axiom_mod=10;
oparms.axiom_only_mod=10;
#endif
}
else if(
( /* CLASS_FGHNF-FSLF22-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFSF21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSMS11-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_C45_F1_PI_AE_Q7_CS_SP_PS_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=7;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUNS-FFSF22-M Solved: 19 of 21 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___060_C18_F1_PI_SE_CS_SP_CO_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.condensing=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUNF-FSLM33-S Solved: 7 of 28 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMF31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____042_B03_F1_AE_Q4_SP_S2S";
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PInvArity;
#endif
}
else if(
( /* CLASS_FUUPM-FFSF21-S Solved: 114 of 123 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "U_____102_C09_12_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecedenceInv;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FUUSM-FFMM32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF21-M Solved: 81 of 103 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF22-S Solved: 11 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUPS-FFSF21-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____0031_gd5";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHHSM-SMLM31-D Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___200_C45_F1_AE_CS_SP_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-SMLM00-S Solved: 16 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____011_C07_F1_PI_SE_SP_S0V";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptRRHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WConstantWeight;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FGHSM-FFMS31-M Solved: 36 of 65 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM32-S Solved: 24 of 43 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___301_C18_F1_URBAN_S5PRR_RG_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSM-FFMS32-S Solved: 38 of 41 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM33-S Solved: 45 of 46 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S2mI";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQArNTNpEqFirst;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSF-FFMM32-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_B07_F1_SE_CS_SP_PS_S4d";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQIPrecWNTNp;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FGHSF-FFMS32-S Solved: 47 of 54 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-SSLM32-D Solved: 67 of 139 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM21-M Solved: 72 of 75 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMF32-S Solved: 21 of 36 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SOS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.use_tptp_sos=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHNF-FMLF00-S Solved: 25 of 25 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMM22-S Solved: 18 of 20 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSS21-M Solved: 7 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLS33-S Solved: 4 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLM00-S Solved: 44 of 98 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLF33-S Solved: 8 of 22 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF21-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLS31-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPM-FFSF21-M Solved: 11 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLM00-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C12_00_F1_SE_CS_PI_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WSelectMaximal;
oparms.to_prec_gen=PByInvFreqHack;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGUSM-FFMF33-S Solved: 56 of 64 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FSMM33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_S2S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-FFMS21-S Solved: 43 of 46 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLF32-M Solved: 23 of 26 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_C36_F1_PI_AE_Q4_CS_SP_PS_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecedence;
oparms.to_prec_gen=PByInvConjFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUPF-FFSS22-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFMS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF21-S Solved: 17 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSMM31-M Solved: 10 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS21-M Solved: 2 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFLM32-D Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSM-FFLS31-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF32-S Solved: 17 of 24 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___300_C01_F1_SE_CS_SP_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
#endif
}
else if(
( /* CLASS_FGHSF-FSLS31-S Solved: 1 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFMM21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FSMS32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-SSLM31-D Solved: 16 of 104 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF21-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMM22-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMM00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSM-MMLM00-S Solved: 10 of 64 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecManyAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____0021_C18_F1_SE_CS_SP_S5PRR_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHHSM-SSLM31-M Solved: 2 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSM-SSLM31-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSM00-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSM-FSLM31-M Solved: 3 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_AE_CS_SP_PS_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSM-SMLM32-D Solved: 150 of 309 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___200_C41_F1_AE_CS_SP_PI_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecRank20;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-FFSF21-S Solved: 47 of 47 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM21-M Solved: 328 of 392 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF21-S Solved: 21 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-SMLF22-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM33-S Solved: 27 of 30 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMF33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLF11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF32-S Solved: 4 of 19 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FMLM32-M Solved: 6 of 66 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF11-S Solved: 13 of 21 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMM32-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLF33-S Solved: 5 of 35 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S032N";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectUnlessUniqMaxOptimalLiteral;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCNormal;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUSM-FFMS21-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S04AN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSS-FFSF22-S Solved: 16 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMF21-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF22-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMF32-M Solved: 18 of 37 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM33-M Solved: 18 of 63 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMF22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___300_C18_F1_SE_CS_SP_PS_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSM-FFSF21-S Solved: 9 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPS-FFSM32-M Solved: 2 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMS21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSF21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPS-FSLM32-S Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHPM-FFSF22-M Solved: 16 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM11-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHSS-FFMM32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMM31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLF31-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSM32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSF21-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS22-S Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM11-S Solved: 20 of 20 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSF22-S Solved: 16 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSF21-M Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFMF21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSM-FFSS22-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF00-S Solved: 39 of 39 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM22-S Solved: 13 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF32-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHPS-FFSF21-D Solved: 10 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMS32-M Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPS-FFSM32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FFMM32-S Solved: 22 of 24 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLM32-D Solved: 5 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMF21-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFSS11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMF21-M Solved: 4 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNS-FFMM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSS-FFMM31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSM32-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPF-FFSF32-D Solved: 1 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHPF-FFMF11-S Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-SMLF00-S Solved: 3 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FSMS31-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FFLM33-D Solved: 1 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSF22-S Solved: 2 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM00-S Solved: 0 of 34 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPM-FFMF33-M Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSS31-M Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSF11-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF00-S Solved: 18 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFLS32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSM33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSM33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF11-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF22-S Solved: 34 of 41 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF22-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM22-S Solved: 10 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSM11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SSLM00-S Solved: 0 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMM32-D Solved: 13 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMM21-D Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FSLM31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMM11-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FSLM21-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF21-S Solved: 2 of 19 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF21-M Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSS-FFSS00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSM00-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMM32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF21-S Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLF33-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSS11-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHPS-FFSF22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSS32-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLS21-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMM22-M Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMS33-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFMF32-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNM-FFSF21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFSS21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF32-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMM21-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-SMLM32-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMF00-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMS11-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSS11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF31-M Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLF33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPM-FSLM31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLS11-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFLM32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHPM-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLF31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSF21-S Solved: 19 of 19 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF31-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMF21-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FSLF31-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNS-FFSF22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF21-S Solved: 11 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF00-S Solved: 98 of 102 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSS21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FMLM00-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSS21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFLS32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNF-FSLM00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMF21-D Solved: 2 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNF-FFMM21-S Solved: 27 of 27 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSM21-S Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSM11-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFLM11-D Solved: 0 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNF-FFMM22-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF22-S Solved: 61 of 61 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSM21-S Solved: 2 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFLM21-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNF-MMLM00-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecManyAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFLS31-D Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMF22-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FMLM33-S Solved: 0 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF22-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF11-S Solved: 67 of 70 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFSS00-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSMS21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHPS-FFSF21-M Solved: 14 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMF33-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFLM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSM21-M Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF33-M Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLM33-S Solved: 3 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLF32-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHSF-SMLM22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMF00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUSF-FFSF21-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFSM00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFLS31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHPF-FFSF21-M Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF33-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-SMLF00-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNS-FFSF00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSS31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMS21-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMS31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF32-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUNS-FFSF00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLS33-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF32-S Solved: 11 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFLM33-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNS-FFSF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-SSLF11-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMF33-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSS33-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNS-FFLM33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FSLM00-S Solved: 2 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUSF-FFSF32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-FFMM21-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSS22-M Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPM-FFSF21-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FMLM21-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSF32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-SSLM00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMM11-S Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHSF-FFSF22-S Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMS22-S Solved: 30 of 30 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFSF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF22-M Solved: 8 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLM31-S Solved: 15 of 30 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMM11-S Solved: 45 of 45 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFLM31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUHPM-FFSF32-M Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-SMLS32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNS-FSLM32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSF32-M Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNS-FFMF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FFSF32-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-SMLM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSS00-S Solved: 14 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-SMLM21-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSS31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSS32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF31-D Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHPF-FSLM21-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMS32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLM21-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF31-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF00-S Solved: 16 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMS32-D Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHPF-FSLM21-D Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF21-D Solved: 38 of 38 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS33-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-FSLM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF32-S Solved: 11 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNS-FFSF11-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF11-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSS21-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLS00-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMS31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUSF-FFSF11-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FFLM32-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLM11-S Solved: 7 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSS31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNS-FFSF21-M Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSS32-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFLS33-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSS31-D Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPF-FSLM32-D Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSS22-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSM00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-FSLM22-S Solved: 4 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-SMLF11-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUSF-FFSF32-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLM21-D Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLM31-S Solved: 2 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMS21-S Solved: 11 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSMM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FSLM00-S Solved: 200 of 200 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFLS32-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSF22-D Solved: 11 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSS11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLS31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSF22-M Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMS32-S Solved: 10 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-FSLM22-M Solved: 9 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNS-FFSF22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMS31-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF31-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLM31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMF11-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSM32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSS00-S Solved: 34 of 34 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF00-S Solved: 34 of 34 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFLF32-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMM31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF33-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-SSLM31-M Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMS32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSS-FFMF22-M Solved: 2 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSF22-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-SMLM11-S Solved: 0 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMS11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFSF21-S Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS31-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF32-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSS21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFSF22-S Solved: 4 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSS00-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMS31-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFSF22-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMS31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS31-D Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSF21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSS21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSS21-S Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMM21-D Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLF22-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSS22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPS-FFMM21-S Solved: 183 of 183 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF11-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSS21-S Solved: 14 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUSM-FFSM11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF11-S Solved: 2 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFMM11-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLS33-D Solved: 4 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLS33-D Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF11-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFLF32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHSM-MMLM31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecManyAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSS22-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FSLF32-D Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF11-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMF22-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSF31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMF33-S Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNS-FFMS21-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF31-D Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPM-FFMM31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF31-M Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF33-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM21-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNS-FFMS21-D Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMS33-D Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPF-FSLM32-S Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-SMLF22-S Solved: 0 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLS31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSM11-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNM-FFSF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMM31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLS32-S Solved: 5 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF22-S Solved: 6 of 137 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFLF11-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS32-M Solved: 2 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS21-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLS32-D Solved: 2 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLF32-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMM31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFLF11-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS32-D Solved: 0 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSF22-M Solved: 8 of 24 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-SSLM00-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFSS21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNS-FFSF22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSF21-S Solved: 13 of 17 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSF21-S Solved: 10 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFMM31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHPF-FFSF22-S Solved: 1 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSM11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS32-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPF-FFMM21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSS32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPS-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-SMLM00-S Solved: 3 of 39 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSS21-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS32-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPS-FFSF21-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSM11-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSF00-S Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-FFMM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-SMLM22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLS31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNM-FFSS11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSS32-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNS-FFSF21-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF32-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FMLS33-S Solved: 0 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLM21-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF33-S Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMF32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFMF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMM33-S Solved: 2 of 29 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF11-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS31-D Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMM21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMM22-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMM22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF11-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFSF22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMM00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-SMLM33-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FSMM22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPM-FFLM31-M Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPM-FFLM31-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNS-FFSF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSMM32-S Solved: 7 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FSMM31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS11-S Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FMLM32-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FSMF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPM-FFLF33-M Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM32-D Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLS32-D Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNM-FFSF21-M Solved: 3 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSS00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMM21-M Solved: 28 of 28 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMF22-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF33-S Solved: 4 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNS-FFMS00-S Solved: 2 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFLF33-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSM-FFSF21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMS21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSS11-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF32-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNS-FFSF11-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF32-M Solved: 10 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF11-S Solved: 11 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMM32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF31-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSF22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FMLF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSF32-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSF21-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSMF11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFSF21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLS33-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFLS33-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMF22-D Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNM-FFSF21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS33-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF31-D Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMS32-M Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSF21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFLF32-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSF22-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF22-S Solved: 9 of 42 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLF11-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNM-FFSF22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF33-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF32-S Solved: 3 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLF11-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPF-SSLM21-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF31-D Solved: 1 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSM22-S Solved: 12 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSF31-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFMM11-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUSM-FFMM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMF32-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPF-FFSF00-S Solved: 2 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMM21-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLF33-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMM21-M Solved: 10 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-SMLF00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FFLF32-D Solved: 1 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUHPF-FFSF21-D Solved: 16 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSF31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSS11-S Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FSLS11-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFLM31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUPS-FFSF21-M Solved: 4 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMF22-D Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPM-FFMF22-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFMF21-S Solved: 27 of 33 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFSS11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMF22-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS33-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMM11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-SMLM33-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMM32-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-SMLM33-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMM32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS11-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMM22-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMS31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLM00-S Solved: 0 of 54 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF21-M Solved: 14 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNM-FFLF21-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMM31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FMLM31-M Solved: 0 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM31-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPS-FFSF21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-MMLM32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecManyAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMM33-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFLM31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSM22-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF31-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-SMLM32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSF32-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLS00-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF31-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMF11-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMF21-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHPF-FFLM22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMM00-S Solved: 18 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMF11-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUHPF-FFSF00-S Solved: 11 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMM33-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFMF21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLM33-D Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSS22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMF32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS00-S Solved: 1 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSS31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHNF-FSMS11-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFMS21-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPF-SSLF32-D Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMM22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMM00-S Solved: 30 of 30 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUNF-FFSS22-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFMS21-S Solved: 7 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF11-M Solved: 13 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF00-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSM22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMF31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF11-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-SSLS32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSM22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMM22-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLS32-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLS32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMF21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSM33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSM00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLM22-S Solved: 12 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLS32-D Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSS21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF31-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM32-D Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSS00-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNS-FFSF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHPM-FFSF22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM32-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFSF11-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMF31-M Solved: 1 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMM31-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUHNS-FFSF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFSF33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFSF21-M Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSS21-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSF33-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FSLM00-S Solved: 0 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF31-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF22-S Solved: 27 of 27 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF31-D Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSS21-S Solved: 12 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSS31-D Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSF31-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSS22-S Solved: 29 of 29 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FFSM32-S Solved: 12 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMM21-M Solved: 0 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMM22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF32-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMS31-D Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSM22-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM33-M Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-SMLS11-S Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHSF-FSMM33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUSF-FFSF22-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLF32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF11-S Solved: 25 of 34 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSM00-S Solved: 0 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFLM33-D Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FMLS31-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFLS32-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF21-M Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSS31-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFLM33-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF00-S Solved: 21 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSF32-S Solved: 11 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FSLF21-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FSLS11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF31-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FMLM22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHPF-FFSF11-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMF32-D Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSS32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSF-FSLM31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFSS21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF00-S Solved: 3 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLM00-S Solved: 0 of 27 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMS21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSM21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSS32-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLM31-D Solved: 2 of 39 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMM31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-SSLM22-S Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSF21-M Solved: 2 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSS-FFMS31-D Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLM32-D Solved: 2 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNM-FFSF11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPF-FFSF22-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLM22-S Solved: 8 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPF-FFSF21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSMM11-S Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF11-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLM32-D Solved: 85 of 92 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMS21-S Solved: 17 of 17 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-SMLF11-S Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMS22-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSF11-S Solved: 13 of 15 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFSS11-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-SMLF33-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMM22-S Solved: 23 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-SMLF33-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLM31-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLM22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMF33-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-SMLF11-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLM31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF22-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF21-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS00-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPM-FFSF31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSF22-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLS33-D Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPM-FFSS22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSS32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF22-S Solved: 3 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSM-FFMM22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-SSLM31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF21-S Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMS22-S Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSM21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-SMLS11-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FMLM21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMM33-S Solved: 13 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSS22-S Solved: 25 of 25 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNS-FFSF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FSLM21-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSS21-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-FSLM22-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNM-SSLM00-S Solved: 0 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFSF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHNF-FFSF32-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSF31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHPM-FFSF21-M Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNS-FFSS00-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUSF-FFSF00-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSM32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-FSLS31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF11-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSF32-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF11-M Solved: 18 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHPS-FFSM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSS22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMM32-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMM31-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLM11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSS00-S Solved: 29 of 40 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF33-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FMLF21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFSF22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF33-S Solved: 4 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSF32-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSM11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSM00-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLS00-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-FFSF11-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHPF-FFSF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSM22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSM22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS31-D Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMM00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF33-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFMM21-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSMM21-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-SSLM33-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM33-M Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSS31-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM11-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-FFLM21-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSS32-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFSF31-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMS22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSF11-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFSM33-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS22-S Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHPF-FFLM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSS22-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHPF-FFLM22-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMS22-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FSMM32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPS-FFMF22-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSS-FFMS32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSS21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSS21-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMF32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSS21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSMM32-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FSLF33-S Solved: 0 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFMF11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSF11-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPS-FFSF32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-FFMF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMS31-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLM33-D Solved: 6 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMM31-S Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPS-FFSF32-S Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSF11-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMF22-S Solved: 9 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMS11-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FFSF21-S Solved: 7 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFSF31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMS21-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHNS-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMS22-M Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMS21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM31-D Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS32-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHPM-FFMM21-M Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNF-SMLM33-S Solved: 0 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF21-S Solved: 1 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFMS31-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF21-S Solved: 10 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-FSLM32-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF21-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMM32-M Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-FFSM31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUUPM-SSLM31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF21-D Solved: 50 of 51 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMM21-M Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSS21-S Solved: 15 of 15 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM00-S Solved: 20 of 20 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPF-SSLM32-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLF32-D Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS22-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF22-S Solved: 10 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSS32-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSMM21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FSLM32-S Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMF22-M Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF31-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMM31-D Solved: 1 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSS11-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPF-SSLM33-S Solved: 2 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSS31-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSM-SSLM32-D Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS21-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNS-FFMS00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS21-D Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSS-FFSS32-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFSS11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFSF00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLS32-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSS32-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF22-S Solved: 0 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNF-FFMS00-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHPM-FFSS21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFMM31-M Solved: 16 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSS31-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFMM32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHNF-SSLS11-S Solved: 0 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSS-FFMM33-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSS-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMM31-M Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHNM-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-SMLS00-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHSM-FFMM21-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMM21-S Solved: 23 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSS-FFSF21-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSS31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSF-SMLF00-S Solved: 6 of 37 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMF32-S Solved: 25 of 62 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_B07_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFrequency;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=0;
oparms.conj_axiom_mod=0;
oparms.axiom_only_mod=0;
#endif
}
else if(
( /* CLASS_FHHNF-FFSF21-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUHPF-FFSF22-M Solved: 1 of 24 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF22-D Solved: 21 of 31 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF22-M Solved: 16 of 52 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___209_C18_F1_AE_CS_SP_PI_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-FFMM21-S Solved: 43 of 99 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSS33-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF21-D Solved: 4 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMS21-M Solved: 8 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSF-FFSS21-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNM-FFMF21-S Solved: 16 of 27 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMF21-S Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___110_C45_F1_PI_SE_CS_SP_PS_S4S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHPNS;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHHNS-FSLM32-M Solved: 207 of 207 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___302_C18_F1_URBAN_RG_S04BN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptUniqMaxHorn;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHNF-FMLS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_AE_Q7_CS_SP_CO_PS_S00";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNoLiterals;
control->heuristic_parms.split_clauses=7;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.condensing=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-FFMF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=10;
oparms.conj_axiom_mod=5;
oparms.axiom_only_mod=0;
#endif
}
else if(
( /* CLASS_FUUPM-FFSF32-D Solved: 5 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSF21-M Solved: 53 of 60 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSF21-D Solved: 23 of 32 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____X1276__C12_02_nc_F1_AE_CS_SP_S5PRR_S2S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PByInvFreqHack;
#endif
}
else if(
( /* CLASS_FGHPF-SSLM21-M Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMS21-M Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_AE_CS_SP_PI_S0e";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectLargestNegativeLiteral;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUPS-FFSF22-M Solved: 4 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF21-D Solved: 1 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____102_C18_F1_PI_AE_CS_SP_PS_S2S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUSS-FFSF21-S Solved: 17 of 20 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_B00_00_F1_PI_AE_Q4_CS_SP_PS_S071I";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQArEqLast;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=LPO4;
oparms.to_weight_gen=WSelectMaximal;
oparms.to_prec_gen=PUnaryFirst;
#endif
}
else if(
( /* CLASS_FGHSF-FSLM22-M Solved: 27 of 37 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSS-FFSF22-S Solved: 22 of 23 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUPS-FFMF32-D Solved: 4 of 28 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPS-FFLF32-D Solved: 6 of 17 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____402_C05_02_F1_SE_CS_SP_PS_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PInvArConstMin;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSF-FFSF00-S Solved: 12 of 15 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM32-S Solved: 180 of 205 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_SE_CS_SP_PI_PS_S2SA";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMax;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSM-FFMF21-S Solved: 43 of 49 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S4b";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQIPrecW;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-FMLF31-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMM22-S Solved: 5 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_AE_CS_SP_PS_S3S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHPExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSS-FFMF33-S Solved: 41 of 56 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLM31-M Solved: 50 of 280 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM32-S Solved: 16 of 42 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "h208_C09_12_F1_SE_CS_SP_PS_S070I";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectVGNonCR;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecedenceInv;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUNF-FFSF21-D Solved: 6 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "U_____206e_02_C10_23_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.eqdef_incrlimit=LONG_MIN;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvModFreqRank;
oparms.to_prec_gen=PByInvFreqConjMin;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FHHNF-FFSF22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_AE_CS_SP_PI_PS_S2U";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHPExceptRRHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUSM-FFSM22-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSF32-S Solved: 17 of 17 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFLF00-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FMLM33-S Solved: 3 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FFSF11-S Solved: 40 of 40 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FFSF33-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHSM-FFMF32-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHPF-FFSF21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSS32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSS-FFSF22-S Solved: 9 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMM22-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFMM21-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM32-M Solved: 14 of 20 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMF31-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FFLF33-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSS21-S Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSF11-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHHNM-SSLM31-M Solved: 51 of 51 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFLF21-M Solved: 6 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMF21-S Solved: 28 of 31 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSF21-S Solved: 5 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNS-FFMM32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSF32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNS-FFMM32-M Solved: 11 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSS21-S Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUPM-FFMF32-M Solved: 2 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLF00-S Solved: 1 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S4d";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQIPrecWNTNp;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-FFMF21-S Solved: 44 of 57 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-SSLM32-M Solved: 44 of 59 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSM-FFSF21-M Solved: 15 of 17 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AI";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGUNS-FFMF11-S Solved: 2 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FFMM33-S Solved: 1 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSMF11-S Solved: 4 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMF11-S Solved: 52 of 59 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SSLF00-S Solved: 4 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNS-FSMF11-S Solved: 5 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C47_F1_SE_CS_SP_PS_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityWeight ;
oparms.to_prec_gen=PArity;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSM-FFMF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S05BN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectUnlessUniqMaxSmallestOrientable;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCNormal;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-FSLM32-S Solved: 62 of 72 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSMM32-M Solved: 10 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLM33-S Solved: 69 of 116 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PI_PS_S5PRR_S032N";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectUnlessUniqMaxOptimalLiteral;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCNormal;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSM-FFMM21-S Solved: 81 of 91 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C02CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WConstantWeight;
oparms.to_prec_gen=PArity;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=10;
oparms.conj_axiom_mod=5;
oparms.axiom_only_mod=0;
#endif
}
else if(
( /* CLASS_FGHSM-FSLM31-S Solved: 21 of 32 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___302_C18_F1_URBAN_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUSM-FFMF21-M Solved: 29 of 44 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___100_C18_F1_PI_AE_Q4_CS_SP_PS_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUNF-FFSF22-M Solved: 56 of 61 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____0019_C18_F1_PI_SE_CS_SP_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHHSM-FSLM31-S Solved: 3 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SMLM32-M Solved: 60 of 71 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___212_C18_F1_AE_Q12_CS_SP_S2S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.split_clauses=12;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.use_tptp_sos=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSS-FFMM33-S Solved: 3 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_B42_F1_PI_SE_Q4_CS_SP_PS_S0YI";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFreqConjMax;
#endif
}
else if(
( /* CLASS_FHUNF-FFMM00-S Solved: 20 of 21 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_AE_CS_SP_PS_S3S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHPExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUPS-FFMM32-S Solved: 5 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___024_B31_F1_PI_AE_Q4_CS_SP_S2S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFreqConstMin;
#endif
}
else if(
( /* CLASS_FHHSM-FFMF21-M Solved: 4 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___200_B02_F1_AE_CS_SP_PI_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PArity;
#endif
}
else if(
( /* CLASS_FUUPM-SMLM31-D Solved: 7 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSS-SMLM31-M Solved: 39 of 152 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "SAT001_MinMin_NN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=2000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
control->heuristic_parms.sat_check_normconst=true;
control->heuristic_parms.sat_check_normalize=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSM-FFSS22-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSF22-M Solved: 12 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____047_C45_F1_AE_R8_CS_SP_S2S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.split_clauses=8;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSF-FFMM21-M Solved: 99 of 139 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____429_C05_02_F1_SE_CS_SP_PS_RG_S04AI";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PInvArConstMin;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGUNF-FSLF33-S Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM32-M Solved: 15 of 39 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___300_C18_F1_URBAN_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUNF-FFSF22-D Solved: 4 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S00";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNoLiterals;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUPF-FFSF22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FMLM32-D Solved: 1 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLS32-M Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___302_C18_F1_URBAN_S5PRR_RG_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSM-FFMF21-M Solved: 18 of 21 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_B00_00_F1_SE_CS_SP_PS_S5PRR_S00EN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectSmallestOrientableLiteral;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCNormal;
oparms.ordertype=LPO4;
oparms.to_weight_gen=WSelectMaximal;
oparms.to_prec_gen=PUnaryFirst;
#endif
}
else if(
( /* CLASS_FGHSS-SSLM32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPS-SSLF32-D Solved: 1 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSF-FFMM00-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSF-FSLM32-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM32-M Solved: 112 of 378 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_SE_CS_SP_PI_PS_S5PRR_RG_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FHUNF-FFLM00-S Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUNF-FFMM32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSM-FFMF32-S Solved: 2 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_SE_CS_SP_PI_PS_S00I";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNoLiterals;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-FFMM21-S Solved: 87 of 98 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMM21-S Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_S2v";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQArNTNp;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUNM-FFSF21-M Solved: 75 of 94 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNS-FFSF22-D Solved: 4 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S3b";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQArNTEqFirstUnlessPDom;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSM-FFMS21-S Solved: 12 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "U_____115v_C12_07_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvArityWeight;
oparms.to_prec_gen=PByInvFreqHack;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGUPS-FSLF32-D Solved: 2 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUNF-FFSF11-S Solved: 22 of 22 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNM-FFMS31-M Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-FFSM21-S Solved: 3 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSMM31-M Solved: 13 of 15 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUNM-FFSM21-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMF31-M Solved: 35 of 42 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPM-FFSF32-M Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS31-D Solved: 1 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04BN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FHUPS-FFSS22-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____0029_C18_F1_PI_SE_CS_SP_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSM-FFMS33-S Solved: 10 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLS31-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FSLM32-M Solved: 3 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C02AMC_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WConstantWeight;
oparms.to_prec_gen=PArity;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=0;
oparms.conj_axiom_mod=5;
oparms.axiom_only_mod=10;
#endif
}
else if(
( /* CLASS_FGHSS-SSLM00-S Solved: 1 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____Z1410__C12_02_nc_F1_AE_CS_SP_S2S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PByInvFreqHack;
#endif
}
else if(
( /* CLASS_FGUNF-FFMM21-S Solved: 70 of 147 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___006_C18_F1_PI_AE_Q4_CS_SP_S2S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-FSLM33-S Solved: 54 of 73 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_C41_F1_PI_AE_Q4_CS_SP_PS_S4S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHPNS;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecRank20;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUPF-FFMF32-D Solved: 13 of 18 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____011_C18_F1_PI_SE_SP_S2S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-FSMM00-S Solved: 119 of 139 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FSMS00-S Solved: 23 of 24 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_N___023_B07_F1_SP_PI_Q7_CS_SP_CO_S5PRR_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=7;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.condensing=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FGHSM-FSLM32-D Solved: 228 of 392 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___301_C18_F1_URBAN_S5PRR_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSM-FFMM31-M Solved: 267 of 674 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_C37_SOS_F1_PI_AE_Q4_CS_SP_PS_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.use_tptp_sos=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityWeight ;
oparms.to_prec_gen=PByInvConjFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-FMLM31-S Solved: 6 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "U_____043_B31_F1_PI_AE_CS_SP_S2S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_weight_gen=WInvFrequencyRank;
#endif
}
else if(
( /* CLASS_FGHSM-SMLF33-S Solved: 3 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "SAT001_MinMin_rr_RG";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSM-FFLS31-M Solved: 9 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "U_____206d_00_C11_23_F1_SE_PI_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.eqdef_incrlimit=LONG_MIN;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvModFreqRank;
oparms.to_prec_gen=PByInvFreqConstMin;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FHHSM-FSLM31-D Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_AE_CS_SP_PI_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-FSLM21-M Solved: 409 of 523 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMS21-D Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_SOS_F1_SE_CS_SP_PS_S4c";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQPrecWNTNp;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.use_tptp_sos=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSM-SMLM32-M Solved: 51 of 377 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S2g";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQArNpEqFirst;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHNF-FSLM32-S Solved: 13 of 24 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSF21-S Solved: 33 of 38 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMS00-S Solved: 13 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-SSLM11-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSS21-D Solved: 2 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSS-FFMM31-S Solved: 8 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___207_C18_F1_AE_CS_SP_PI_PS_S0S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexG;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FUUNF-FFSF00-S Solved: 34 of 205 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___107_C48_F1_PI_AE_Q4_CS_SP_PS_S0Y";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecRank5;
oparms.to_prec_gen=PByInvFreqConjMin;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSF-FFMM32-M Solved: 11 of 11 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF21-D Solved: 16 of 22 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM31-S Solved: 40 of 58 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FSMM31-S Solved: 8 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSS22-S Solved: 9 of 9 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18C___F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=10;
oparms.conj_axiom_mod=0;
oparms.axiom_only_mod=0;
#endif
}
else if(
( /* CLASS_FHHNM-FSLM31-M Solved: 7 of 12 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSM-SMLM31-M Solved: 57 of 107 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHHSM-FFMM31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____0021_10gd3";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGHSF-SMLM33-S Solved: 48 of 112 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSF21-M Solved: 219 of 282 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C12_11_nc_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCNormal;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecedence;
oparms.to_prec_gen=PByInvFreqHack;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FHUSS-FFSM22-S Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-MMLM11-S Solved: 3 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecManyAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____0010_evo";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FUUPM-FFMF21-D Solved: 61 of 69 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPM-FFSF22-M Solved: 4 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF21-M Solved: 219 of 277 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____047_C09_12_F1_AE_ND_CS_SP_S5PRR_S2S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
control->heuristic_parms.eqdef_incrlimit=LONG_MIN;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WPrecedenceInv;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FUUPS-FFSF22-D Solved: 36 of 39 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_____Z1014__C12_02_nc_F1_AE_CS_SP_S2S";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WArityMax0;
oparms.to_prec_gen=PByInvFreqHack;
#endif
}
else if(
( /* CLASS_FGHSS-FFMM32-M Solved: 7 of 7 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUSF-FFMS32-S Solved: 4 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSS-FSLM32-M Solved: 37 of 45 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_B07_F1_S5PRR_SE_CS_SP_PS_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FHUNS-FFSF21-M Solved: 88 of 90 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____011_C07_F1_PI_AE_Q4_CS_SP_PS_S0V";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptRRHorn;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WConstantWeight;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FGHSF-FSLS33-S Solved: 8 of 39 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSF-FSLF33-S Solved: 6 of 17 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___008_C45_F1_PI_SE_Q4_CS_SP_S4SI";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHPNS;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFreqConjMax;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FHUNM-FFSF21-D Solved: 7 of 26 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUPS-FSLM32-M Solved: 2 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHPF-FFSF32-M Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGUPS-SSLM32-M Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FHUNF-SMLM00-S Solved: 3 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUSS-FFMF22-D Solved: 12 of 44 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUNM-FFMF31-S Solved: 1 of 1 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHHNM-FFMS21-D Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUPM-FFSF22-M Solved: 11 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF32-M Solved: 31 of 55 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPF-FFSF32-M Solved: 5 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF22-M Solved: 46 of 134 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF22-D Solved: 6 of 41 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGHSF-FFMM31-M Solved: 13 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFLM32-M Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSS-SMLM00-S Solved: 3 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FHUSM-FFMS21-M Solved: 2 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUUPM-FFSF31-M Solved: 6 of 15 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreUnit(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FSLM33-S Solved: 1 of 8 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMS31-S Solved: 10 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___302_C18_F1_URBAN_S5PRR_RG_S04BN";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=PSelectComplexExceptUniqMaxHorn;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGUSF-FFMM33-M Solved: 2 of 4 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____047_B31_F1_PI_AE_R4_CS_SP_S4c";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectCQPrecWNTNp;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFreqConstMin;
#endif
}
else if(
( /* CLASS_FGHSM-FFMF32-M Solved: 8 of 13 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S038I";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectUnlessUniqMaxPosOptimalLiteral;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.lit_cmp=LCTFOEqMin;
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FUHPF-FFSF22-D Solved: 2 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F2_SE_CS_SP_PS_S5PRR_RG_S04A";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=2;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
else if(
( /* CLASS_FGHSF-FSLM32-M Solved: 40 of 58 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity2(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FGHSM-FFMM31-S Solved: 92 of 153 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHSM-SMLM31-D Solved: 11 of 39 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecSomeAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "C07_19_nc_SOS_SAT001_MinMin_rr";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.use_tptp_sos=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FGHNF-FFMM00-S Solved: 51 of 60 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity0(spec)&&
SpecAvgFArity0(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____011_C07_F1_PI_AE_OS_S1U";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.selection_strategy=SelectComplexAHPExceptRRHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodOrientedSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WConstantWeight;
oparms.to_prec_gen=PByInvFrequency;
#endif
}
else if(
( /* CLASS_FGHNF-FMLS31-S Solved: 3 of 3 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecManyLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGUNF-FSLF11-S Solved: 8 of 16 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecSomeLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FGHNF-FFMM11-M Solved: 4 of 5 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreHorn(spec)&&
SpecNoEq(spec)&&
SpecFewNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecManyGroundPos(spec)&&
SpecMaxFArity1(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_B07CMA_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFrequency;
oparms.rewrite_strong_rhs_inst=true;
oparms.conj_only_mod=10;
oparms.conj_axiom_mod=5;
oparms.axiom_only_mod=0;
#endif
}
else if(
( /* CLASS_FUHPM-FFSF21-M Solved: 52 of 55 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecMediumMaxDepth(spec))
||
( /* CLASS_FUHPM-FFSF21-D Solved: 6 of 6 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FHUSM-FFSF22-S Solved: 36 of 45 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity2(spec)&&
SpecShallowMaxDepth(spec))
||
( /* CLASS_FUHPM-FFMF21-D Solved: 24 of 24 */
SpecIsFO(spec)&&
SpecAxiomsAreUnit(spec)&&
SpecGoalsAreHorn(spec)&&
SpecPureEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "H_____047_B31_F1_PI_AE_R4_CS_SP_S2S";
control->heuristic_parms.prefer_initial_clauses=true;
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectNewComplexAHP;
control->heuristic_parms.split_clauses=4;
control->heuristic_parms.split_aggressive=true;
control->heuristic_parms.split_fresh_defs=false;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=LPO4;
oparms.to_prec_gen=PByInvFreqConstMin;
#endif
}
else if(
( /* CLASS_FHUSM-FFSF21-D Solved: 5 of 10 */
SpecIsFO(spec)&&
SpecAxiomsAreNonUnitHorn(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecSmallTerms(spec)&&
SpecFewGroundPos(spec)&&
SpecMaxFArity2(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec))
||
( /* CLASS_FGUSM-FFLS31-D Solved: 1 of 2 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecManyNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecLargeTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity1(spec)&&
SpecDeepMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S0Y_ni";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else if(
( /* CLASS_FGUSS-FFMS33-S Solved: 8 of 14 */
SpecIsFO(spec)&&
SpecAxiomsAreGeneral(spec)&&
SpecGoalsAreUnit(spec)&&
SpecSomeEq(spec)&&
SpecSomeNGPosUnits(spec)&&
SpecFewAxioms(spec)&&
SpecFewLiterals(spec)&&
SpecMediumTerms(spec)&&
SpecSomeGroundPos(spec)&&
SpecMaxFArity3Plus(spec)&&
SpecAvgFArity3Plus(spec)&&
SpecShallowMaxDepth(spec)))
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___211_C18_F1_AE_CS_SP_S0Y";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectMaxLComplexAvoidPosPred;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
#endif
}
else /* Default */
{
#ifdef CHE_HEURISTICS_INTERNAL
res = "G_E___208_C18_F1_SE_CS_SP_PS_S5PRR_RG_S04AN";
control->heuristic_parms.forward_context_sr = true;
control->heuristic_parms.selection_strategy=SelectComplexExceptUniqMaxHorn;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_strong_destructive=true;
control->heuristic_parms.er_varlit_destructive=true;
control->heuristic_parms.er_aggressive=true;
control->heuristic_parms.forward_demod=1;
control->heuristic_parms.pm_type=ParamodSim;
control->heuristic_parms.presat_interreduction=true;
control->heuristic_parms.sat_check_step_limit=5000;
control->heuristic_parms.sat_check_grounding=GMConjMinMinFreq;
#endif
#ifdef TO_ORDERING_INTERNAL
oparms.ordertype=KBO6;
oparms.to_weight_gen=WInvFrequencyRank;
oparms.to_prec_gen=PByInvFrequency;
oparms.to_const_weight=1;
oparms.rewrite_strong_rhs_inst=true;
#endif
}
#endif
/* Total solutions on test set: 11286 */
/* -------------------------------------------------------*/
/* End of automatically generated code. */
/* -------------------------------------------------------*/
| |
sha256.h |
#ifndef SHA256_H
#define SHA256_H
#include <string.h>
#include <stdio.h>
#include "bitfn.h"
#include "util.h"
struct sha256_ctx
{
unsigned int h[8];
unsigned char buf[128];
unsigned long long sz;
};
typedef struct { unsigned int digest[8]; } sha256_digest;
/**
* sha256_init - Init SHA256 context
*/
static void sha256_init(struct sha256_ctx *ctx)
{
memset(ctx, 0, sizeof(*ctx));
ctx->h[0] = 0x6a09e667;
ctx->h[1] = 0xbb67ae85;
ctx->h[2] = 0x3c6ef372;
ctx->h[3] = 0xa54ff53a;
ctx->h[4] = 0x510e527f;
ctx->h[5] = 0x9b05688c;
ctx->h[6] = 0x1f83d9ab;
ctx->h[7] = 0x5be0cd19;
}
/**
* sha256_copy - Copy SHA256 context
*/
static void sha256_copy(struct sha256_ctx *dst, struct sha256_ctx *src)
{
memcpy(dst, src, sizeof(*dst));
}
/* 232 times the cube root of the first 64 primes 2..311 */
static const unsigned int k[] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
static inline unsigned int Ch(unsigned int x, unsigned int y, unsigned int z)
{
return z ^ (x & (y ^ z));
}
static inline unsigned int Maj(unsigned int x, unsigned int y, unsigned int z)
{
return (x & y) | (z & (x | y));
}
#define e0(x) (ror32(x, 2) ^ ror32(x,13) ^ ror32(x,22))
#define e1(x) (ror32(x, 6) ^ ror32(x,11) ^ ror32(x,25))
#define s0(x) (ror32(x, 7) ^ ror32(x,18) ^ (x >> 3))
#define s1(x) (ror32(x,17) ^ ror32(x,19) ^ (x >> 10))
/**
* sha256_do_chunk - Process a block through SHA256
*/
static void sha256_do_chunk(unsigned char __W[], unsigned int H[])
{
unsigned int a, b, c, d, e, f, g, h, t1, t2;
unsigned int W[64];
int i;
for (i = 0; i < 16; i++)
W[i] = be32_to_cpu(((unsigned int *) __W)[i]);
for (i = 16; i < 64; i++)
W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
a = H[0];
b = H[1];
c = H[2];
d = H[3];
e = H[4];
f = H[5];
g = H[6];
h = H[7];
#define T(a, b, c, d, e, f, g, h, k, w) \
do { \
t1 = h + e1(e) + Ch(e, f, g) + k + w; \
t2 = e0(a) + Maj(a, b, c); \
d += t1; \
h = t1 + t2; \
} while (0)
#define PASS(i) \
do { \
T(a, b, c, d, e, f, g, h, k[i + 0], W[i + 0]); \
T(h, a, b, c, d, e, f, g, k[i + 1], W[i + 1]); \
T(g, h, a, b, c, d, e, f, k[i + 2], W[i + 2]); \
T(f, g, h, a, b, c, d, e, k[i + 3], W[i + 3]); \
T(e, f, g, h, a, b, c, d, k[i + 4], W[i + 4]); \
T(d, e, f, g, h, a, b, c, k[i + 5], W[i + 5]); \
T(c, d, e, f, g, h, a, b, k[i + 6], W[i + 6]); \
T(b, c, d, e, f, g, h, a, k[i + 7], W[i + 7]); \
} while (0)
PASS(0);
PASS(8);
PASS(16);
PASS(24);
PASS(32);
PASS(40);
PASS(48);
PASS(56);
#undef T
#undef PASS
H[0] += a;
H[1] += b;
H[2] += c;
H[3] += d;
H[4] += e;
H[5] += f;
H[6] += g;
H[7] += h;
}
/**
* sha256_update - Update the SHA256 context values with length bytes of data
*/
static void sha256_update(struct sha256_ctx *ctx, unsigned char *data, int len)
{
unsigned int index, to_fill;
/* check for partial buffer */
index = (unsigned int) (ctx->sz & 0x3f);
to_fill = 64 - index;
ctx->sz += len;
/* process partial buffer if there's enough data to make a block */
if (index && len >= to_fill) {
memcpy(ctx->buf + index, data, to_fill);
sha256_do_chunk(ctx->buf, ctx->h);
len -= to_fill;
data += to_fill;
index = 0;
}
/* process as much 64-block as possible */
for (; len >= 64; len -= 64, data += 64)
sha256_do_chunk(data, ctx->h);
/* append data into buf */
if (len)
memcpy(ctx->buf + index, data, len);
}
/**
* sha256_finalize - Finalize the context and create the SHA256 digest
*/
static void sha256_finalize(struct sha256_ctx *ctx, sha256_digest *out)
{
static unsigned char padding[64] = { 0x80, };
unsigned int bits[2];
unsigned int i, index, padlen;
/* cpu -> big endian */
bits[0] = cpu_to_be32((unsigned int) (ctx->sz >> 29));
bits[1] = cpu_to_be32((unsigned int) (ctx->sz << 3));
/* pad out to 56 */
index = (unsigned int) (ctx->sz & 0x3f);
padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
sha256_update(ctx, padding, padlen);
/* append length */
sha256_update(ctx, (unsigned char *) bits, sizeof(bits));
/* store to digest */
for (i = 0; i < 8; i++)
out->digest[i] = cpu_to_be32(ctx->h[i]);
}
/**
* sha256_to_bin - Transform the SHA256 digest into a binary data
*/
static void sha256_to_bin(sha256_digest *digest, char *out)
{
uint32_t *ptr = (uint32_t *) out;
int i;
for (i = 0; i < 8; i++)
ptr[i] = digest->digest[i];
}
/**
* sha256_to_hex - Transform the SHA256 digest into a readable data
*/
static void sha256_to_hex(sha256_digest *digest, char *out)
{
char *p;
int i;
for (p = out, i = 0; i < 8; i++, p += 8)
snprintf(p, 9, "%08x", be32_to_cpu(digest->digest[i]));
}
/**
* sha256_of_bin - Transform binary data into the SHA256 digest
*/
static void sha256_of_bin(const char *in, sha256_digest *digest)
{
memcpy(digest->digest, in, sizeof(*digest));
}
/**
* sha256_of_hex - Transform readable data into the SHA256 digest
*/
static void sha256_of_hex(const char *in, sha256_digest *digest)
{
if (strlen(in) != 64)
return;
of_hex((unsigned char *) digest->digest, in, 64);
}
#endif
| /*
Copyright (C) 2006-2009 Vincent Hanquez <tab@snarc.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* SHA256 implementation
*/ |
a3Bir.mli |
(** Stackless, 3-address like and unstructured intermediate representation for Java Bytecode, in which basic expression trees are reconstructed and method and constructor calls are folded.*)
(** {2 Language} *)
(** {3 Variables} *)
open! Javalib_pack
type var
(** Abstract data type for variables *)
(** [var_equal v1 v2] is equivalent to [v1 = v2], but is faster. *)
val var_equal : var -> var -> bool
(** [var_orig v] is [true] if and only if the variable [v] was already used at
bytecode level. *)
val var_orig : var -> bool
(** [var_name v] returns a string representation of the variable [v]. *)
val var_name : var -> string
(** [var_name_debug v] returns, if possible the original variable names of [v],
if the initial class was compiled using debug information. *)
val var_name_debug : var -> string option
(** [var_name_g v] returns a string representation of the variable [v].
If the initial class was compiled using debug information, original
variable names are build on this information. It is equivalent to
[var_name_g x = match var_name_debug with Some s -> s | _ -> var_name x] *)
val var_name_g : var -> string
(** [bc_num v] returns the local var number if the variable comes from the initial bytecode program. *)
val bc_num : var -> int option
(** [index v] returns the hash value of the given variable. *)
val index : var -> int
(** This module allows to build efficient sets of [var] values. *)
module VarSet : Javalib_pack.GenericSet.GenericSetSig with type elt = var
(** This module allows to build maps of elements indexed by [var] values. *)
module VarMap : Javalib_pack.GenericMap.GenericMapSig with type key = var
(** {3 Expressions} *)
(** Constants *)
type const = JBir.const
(** Conversion operators *)
type conv = I2L | I2F | I2D
| L2I | L2F | L2D
| F2I | F2L | F2D
| D2I | D2L | D2F
| I2B | I2C | I2S
(** Unary operators *)
type unop =
Neg of JBasics.jvm_basic_type
| Conv of conv
| ArrayLength
| InstanceOf of JBasics.object_type
| Cast of JBasics.object_type
(** Comparison operators *)
type comp =
DG (** double comparison, if a value is NaN, push 1 into operand stack. *)
| DL (** double comparison, if a value is NaN, push -1 into operand stack. *)
| FG (** float comparison, if a value is NaN, push 1 into operand stack.*)
| FL (** float comparison, if a value is NaN, push -1 into operand stack.*)
| L (** long comparison. *)
(** Binary operators *)
type binop =
ArrayLoad of JBasics.value_type
| Add of JBasics.jvm_basic_type
| Sub of JBasics.jvm_basic_type
| Mult of JBasics.jvm_basic_type
| Div of JBasics.jvm_basic_type
| Rem of JBasics.jvm_basic_type
| IShl | IShr | IAnd | IOr | IXor | IUshr
| LShl | LShr | LAnd | LOr | LXor | LUshr
| CMP of comp
(** variables are given a type information. *)
type tvar = JBasics.value_type * var
(** Side-effect free expressions. Only variables can be assigned such expressions. *)
type expr =
| Const of const (** constants *)
| Var of tvar
| Unop of unop * tvar
| Binop of binop * tvar * tvar
| Field of tvar * JBasics.class_name * JBasics.field_signature (** Reading fields of arbitrary expressions *)
| StaticField of JBasics.class_name * JBasics.field_signature (** Reading static fields *)
(** [type_of_tvar e] returns the type of the expression [e]. *)
val type_of_tvar : tvar -> JBasics.value_type
(** [type_of_expr e] returns the type of the expression [e]. *)
val type_of_expr : expr -> JBasics.value_type
(** {3 Instructions} *)
type virtual_call_kind =
| VirtualCall of JBasics.object_type
| InterfaceCall of JBasics.class_name
(** [check] is the type of A3Bir assertions. They are generated by the transformation so that execution errors arise
in the same order in the initial bytecode program and its A3Bir version. Next to each of them is the informal semantics they should be given. *)
type check =
| CheckNullPointer of tvar (** [CheckNullPointer e] checks that the expression [e] is not a null pointer and raises the Java NullPointerException if this not the case. *)
| CheckArrayBound of tvar * tvar (** [CheckArrayBound(a,idx)] checks the index [idx] is a valid index for the array denoted by the expression [a] and raises the Java IndexOutOfBoundsException if this is not the case. *)
| CheckArrayStore of tvar * tvar (** [CheckArrayStore(a,e)] checks [e] can be stored as an element of the array [a] and raises the Java ArrayStoreException if this is not the case. *)
| CheckNegativeArraySize of tvar (** [CheckNegativeArray e] checks that [e], denoting an array size, is positive or zero and raises the Java NegativeArraySizeException if this is not the case.*)
| CheckCast of tvar * JBasics.object_type (** [CheckCast(e,t)] checks the object denoted by [e] can be casted to the object type [t] and raises the Java ClassCastException if this is not the case. *)
| CheckArithmetic of tvar (** [CheckArithmetic e] checks that the divisor [e] is not zero, and raises ArithmeticException if this is not the case. *)
| CheckLink of JCode.jopcode
(** [CheckLink op] checks if linkage mechanism, depending on
[op] instruction, must be started and if so if it
succeeds. These instructions are only generated if the
option is activated during transformation (cf. {!transform}).
Linkage mechanism and errors that could be thrown
are described in chapter 6 of JVM Spec 1.5 for each bytecode
instruction (only a few instructions imply linkage
operations: checkcast, instanceof, anewarray,
multianewarray, new, get_, put_, invoke_). *)
(** A3Bir instructions are register-based and unstructured. Their operands are [tvar] (typed local vars), except variable assigments.
Next to them is the informal semantics (using a traditional instruction notations) they should be given.
Exceptions that could be raised by the virtual
machine are described beside each instruction, except for the
virtual machine errors, subclasses of
[java.lang.VirtualMachineError], that could be raised at any time
(cf. JVM Spec 1.5 §6.3 ).
*)
type instr =
| Nop
| AffectVar of var * expr (** [AffectVar(x,e)] denotes x := e. *)
| AffectArray of tvar * tvar * tvar (** [AffectArray(x,i,e)] denotes x\[i\] := e. *)
| AffectField of tvar * JBasics.class_name * JBasics.field_signature * tvar (** [AffectField(x,c,fs,y)] denotes x.<c:fs> := y. *)
| AffectStaticField of JBasics.class_name * JBasics.field_signature * tvar (** [AffectStaticField(c,fs,e)] denotes <c:fs> := e .*)
| Alloc of var * JBasics.class_name
(** [Alloc(x,c)] performs the allocation part of a x:= new c(), without
any constructor call. It is only generated with appropriate options
in the [transform] function below. *)
| Goto of int (** [Goto pc] denotes goto pc. (absolute address) *)
| Ifd of ( [ `Eq | `Ge | `Gt | `Le | `Lt | `Ne ] * tvar * tvar ) * int (** [Ifd((op,x,y),pc)] denotes if (x op y) goto pc. (absolute address) *)
| Throw of tvar (** [Throw x] denotes throw x.
The exception [IllegalMonitorStateException] could be thrown by the virtual machine.*)
| Return of tvar option (** [Return x] denotes
- return void when [x] is [None]
- return x otherwise
The exception [IllegalMonitorStateException] could be thrown
by the virtual machine.
*)
| New of var * JBasics.class_name * JBasics.value_type list * (tvar list) (** [New(x,c,tl,args)] denotes x:= new c<tl>(args), [tl] gives the type of [args]. *)
| NewArray of var * JBasics.value_type * (tvar list) (** [NewArray(x,t,el)] denotes x := new c\[e1\]...\[en\] where ei are the elements of [el] ; they represent the length of the corresponding dimension. Elements of the array are of type [t]. *)
| InvokeStatic
of var option * JBasics.class_name * JBasics.method_signature * tvar list (** [InvokeStatic(x,c,ms,args)] denotes
- c.m<ms>(args) if [x] is [None] (void returning method)
- x := c.m<ms>(args) otherwise
The exception [UnsatisfiedLinkError] could be
thrown if the method is native and the code cannot be
found.
*)
| InvokeVirtual
of var option * tvar * virtual_call_kind * JBasics.method_signature * tvar list (** [InvokeVirtual(x,y,k,ms,args)] denotes the [k] call
- y.m<ms>(args) if [x] is [None] (void returning method)
- x := y.m<ms>(args) otherwise
If [k] is a [VirtualCall _] then the virtual machine could throw the following errors in the same order: [AbstractMethodError, UnsatisfiedLinkError].
If [k] is a [InterfaceCall _] then the virtual machine could throw the following errors in the same order: [IncompatibleClassChangeError, AbstractMethodError, IllegalAccessError, AbstractMethodError, UnsatisfiedLinkError].
*)
| InvokeNonVirtual
of var option * tvar * JBasics.class_name * JBasics.method_signature * tvar list (** [InvokeNonVirtual(x,y,c,ms,args)] denotes the non virtual call
- y.C.m<ms>(args) if [x] is [None] (void returning method)
- x := y.C.m<ms>(args) otherwise
The exception [UnsatisfiedLinkError] could be thrown
if the method is native and the code cannot be found.
*)
| InvokeDynamic
of var option * JBasics.bootstrap_method * JBasics.method_signature * tvar list
| MonitorEnter of tvar (** [MonitorEnter x] locks the object [x]. *)
| MonitorExit of tvar (** [MonitorExit x] unlocks the object [x].
The exception
[IllegalMonitorStateException] could be
thrown by the virtual machine. *)
| MayInit of JBasics.class_name (** [MayInit c] initializes the class [c] whenever it is required.
The exception [ExceptionInInitializerError] could be thrown by the virtual machine.*)
| Check of check (** [Check c] evaluates the assertion [c].
Exceptions that could be thrown by the virtual
machine are described in {!check} type declaration.*)
type exception_handler = {
e_start : int;
e_end : int;
e_handler : int;
e_catch_type : JBasics.class_name option;
e_catch_var : var
}
(** [t] is the parameter type for A3Bir methods. *)
type t
(*Create an empty bir representation. Can be used for stubs.*)
val empty : t
(** All variables that appear in the method. [vars.(i)] is the variable of
index [i]. *)
val vars : t -> var array
(** [params] contains the method parameters (including the receiver this for
virtual methods). *)
val params : t -> (JBasics.value_type * var) list
(** Array of instructions the immediate successor of [pc] is [pc+1]. Jumps
are absolute. *)
val code : t -> instr array
(** [exc_tbl] is the exception table of the method code. Jumps are
absolute. The list is ordered in the same way as in the bytecode
(See JVM Spec 7 $2.10). *)
val exc_tbl : t -> exception_handler list
(** [line_number_table] contains debug information. It is a list of pairs
[(i,j)] where [i] indicates the index into the bytecode array at which the
code for a new line [j] in the original source file begins. *)
val line_number_table : t -> (int * int) list option
(*(** map from bytecode code line to ir code line. It raises Not_found
if pc is not an original bytecode pc or if the corresponding
bytecode instruction has no predecessors and has been removed
because it is unreachable.*)*)
(*val pc_bc2ir : t -> int Ptmap.t*)
(** map from ir code line to bytecode code line: the last bytecode
instruction corresponding to the given ir instruction is
returned (i.e. the last bytecode instruction used for the ir
instruction generation).*)
val pc_ir2bc : t -> int array
(** [jump_target m] indicates whether program points are join points or not in [m]. *)
val jump_target : t -> bool array
(** [exception_edges m] returns a list of edges [(i,e);...] where
[i] is an instruction index in [m] and [e] is a handler whose
range contains [i]. *)
val exception_edges : t -> (int * exception_handler) list
(** [get_source_line_number pc m] returns the source line number corresponding
the program point [pp] of the method code [m]. The line number give a rough
idea and may be wrong. It uses the field [t.pc_ir2bc] of the code
representation and the attribute LineNumberTable (cf. JVMS §4.7.8).*)
val get_source_line_number : int -> t -> int option
val make_fresh_var : t -> var
(** {2 Printing functions} *)
(** [print_handler exc] returns a string representation for exception handler
[exc]. *)
val print_handler : exception_handler -> string
(** [print_tvar e] returns a string representation for basic expression
[e]. *)
val print_tvar : ?show_type:bool -> tvar -> string
(** [print_expr e] returns a string representation for expression [e]. *)
val print_expr : ?show_type:bool -> expr -> string
(** [print_instr ins] returns a string representation for instruction [ins]. *)
val print_instr : ?show_type:bool -> instr -> string
(** [print c] returns a list of string representations for instruction of [c]
(one string for each program point of the code [c]). *)
val print : t -> string list
(** [print_program ~css ~js ~info program outputdir] generates html
files representing the program [p] in the output directory
[outputdir], given the annotation information [info]
([void_info] by default), an optional Cascading Style Sheet
(CSS) [css] and an optional JavaScript file [js]. If [css] or
[js] is not provided, a default CSS or JavaScript file is
generated. @raise Sys_error if the output directory [outputdir]
does not exist. @raise Invalid_argument if the name
corresponding to [outputdir] is a file. *)
val print_program :
?css:string -> ?js:string -> ?info:JPrintHtml.info -> t JProgram.program -> string -> unit
(** [print_class ~css ~js ~info ioc outputdir] generates html files
representing the interface or class [ioc] in the output
directory [outputdir], given the annotation information [info]
([void_info] by default), an optional Cascading Style Sheet
(CSS) [css] and an optional JavaScript file [js]. If [css] or
[js] is not provided, a default CSS or JavaScript file is
generated. No links on types and methods are done when
[print_class] is used, it should only be used when user does not
have the program representation. @raise Sys_error if the output
directory [outputdir] does not exist. @raise Invalid_argument if
the name corresponding to [outputdir] is a file.*)
val print_class :
?css:string -> ?js:string -> ?info:JPrintHtml.info -> t Javalib.interface_or_class -> string -> unit
(** Printer for the Sawja Eclipse Plugin (see module JPrintPlugin) *)
module PluginPrinter : JPrintPlugin.NewCodePrinter.PluginPrinter
with type code = t
and type expr = expr
(** {2 Bytecode transformation} *)
(** [transform ~bcv ~ch_link cm jcode] transforms
the code [jcode] into its A3bir representation. The transformation
is performed in the context of a given concrete method [cm].
- [?bcv]: The type checking normally performed by the ByteCode
Verifier (BCV) is done if and only if [bcv] is [true].
- [?ch_link]: Check instructions are generated when a linkage
operation is done if and only if [ch_link] is [true].
[transform] can raise several exceptions. See exceptions below for details. *)
val transform : ?bcv:bool -> ?ch_link:bool -> JCode.jcode Javalib.concrete_method -> JCode.jcode -> t
(** [resolve_all_fields prog -> prog] : return a new program where every fields
has been resolved to the exact class where they have been defined. If there
are some ambigous fields (it means that some interfaces fields are present)
throw an JControlFlow.AmbigousFieldResolution exception.
*)
val resolve_all_fields : t JProgram.program -> t JProgram.program
(** {2 Exceptions} *)
exception NonemptyStack_backward_jump
(** [NonemptyStack_backward_jump] is raised when a backward jump on a
non-empty stack is encountered. This should not happen if you compiled your
Java source program with the javac compiler *)
exception Subroutine
(** [Subroutine] is raised in case the bytecode contains a subroutine. *)
exception InvalidClassFile
(** [InvalidClassFile] is raised if the layout of a method is unexpected. (please report) *)
| (*
* This file is part of SAWJA
* Copyright (c)2009 Delphine Demange (INRIA)
* Copyright (c)2009 David Pichardie (INRIA)
* Copyright (c)2010 Vincent Monfort (INRIA)
* Copyright (c)2016 David Pichardie (ENS Rennes)
* Copyright (c)2016 Laurent Guillo (CNRS)
*
* This program is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this program. If not, see
* <http://www.gnu.org/licenses/>.
*) |
dune |
(library
(name a_kernel)
(public_name a.kernel)
(kind ppx_rewriter)
(libraries ppxlib))
| |
graph.mli | (** Basic statistics on graphs (experimental) *)
(** [Dist] handles distances between vertices. The distance between
two vertices is the length of a shortest path between those vertices. *)
module Dist : sig
type t = Inf | Fin of int
(** The distance between two vertices is [zero] iff they are equal. *)
val zero : t
(** The distance between two vertices is [one] iff they are adjacent. *)
val one : t
(** The distance between two vertices is [infty] iff they are disconnected. *)
val infty : t
(** Adding distances. *)
val ( + ) : t -> t -> t
(** Comparing distances. *)
val ( > ) : t -> t -> bool
(** Testing distance for equality. *)
val ( = ) : t -> t -> bool
(** Computing the [max] of two distances. *)
val max : t -> t -> t
(** Pretty printing. *)
val pp : Format.formatter -> t -> unit
end
module type Graph_statistics = sig
(** [t] is the type of (undirected) graphs. *)
type t
(** [vertex] is the type of vertices. *)
type vertex
type matrix = (int * int, float) Stats_intf.fin_fun
(** Undirected edges. The [equal] and [hash] function are invariant under permutation
of the vertices in the pair encoding the edge. *)
module Undirected_edge : Basic_intf.Std with type t = vertex * vertex
(** [Table] is a hashtable module with undirected edges as keys. *)
module Table : Hashtbl.S with type key = Undirected_edge.t
(** [Vertex_set] handles sets of vertices. *)
module Vertex_set : Set.S with type elt = vertex
(** [Vertex_table] is a hashtable module with vertices as keys. *)
module Vertex_table : Hashtbl.S with type key = vertex
(** Finite bijections between vertices and integers. *)
module Vertex_bij : Finbij.S with type elt = vertex
(** [adjacency_matrix g] computes the adjacency matrix of [g] as well as a
bijection between the matrix dimensions and the vertices. The matrix is
dense. Since the graph is undirected, it is also symmetric. *)
val adjacency_matrix : t -> matrix * Vertex_bij.t
(** [laplacian g] computes the laplacian of the adjacency matrix,
following the definition in 'Spectral Graph Theory', by Fan Chung Graham.
The dimensions are the same as the adjacency matrix.
A finite bijection is returned as well. *)
val laplacian : t -> matrix * Vertex_bij.t
type distance_table = (vertex * vertex, Dist.t) Hashtbl.t
(** Floyd-warshall algorithm. Complexity is O(V^3) where V is the number of
vertices of the graph. Returns a table of all distances between pairs of
vertices. *)
val floyd_warshall : t -> Dist.t Table.t
(** Computes the diameter of the graph, ie the maximum over all pair of vertices
of the shortest-path distance between those vertices. *)
val diameter : t -> Dist.t
(** [volume g] computes the sum over all vertices of their degree. *)
val volume : t -> int
(** [connected_component g v predicate] produces the connected component of [v] in [g]
that satisfies the given predicate. *)
val connected_component : t -> vertex -> (vertex -> bool) -> vertex Seq.t
(** See {!connected_component}. Returns a table instead of a {!Seq.t}. *)
val connected_component_ :
t -> vertex -> (vertex -> bool) -> unit Vertex_table.t
(** [is_induced_subgraph_connected g predicate] is true if the subgraph of [g] induced by
[predicate] is connected. *)
val is_induced_subgraph_connected : t -> (vertex -> bool) -> bool
(** [degree_dist g] computes the degree distribution of [g]. *)
val degree_dist : t -> (int, float) Stats_intf.fin_prb
(** [cut g set] computes the {e cut} associated to [set], i.e.
the subset of edges that have an end in [set] and the other end
in the complement of [set]. *)
val cut : t -> Vertex_set.t -> (vertex * vertex) list
(** [Tree] defines a type of trees and functions to construct, deconstruct and iterate on those trees. *)
module Tree : sig
type t
(** [cons v sub] constructs a tree with root [v] and subtrees [sub]. *)
val cons : vertex -> t list -> t
(** [uncons t] deconstructs [t] into a pair of its root and its subtrees. *)
val uncons : t -> vertex * t list
(** [mem_vertex t v] *)
val mem_vertex : t -> vertex -> bool
(** [iter_vertices t f] iterates [f] on the nodes of [t]. *)
val iter_vertices : t -> (vertex -> unit) -> unit
(** [iter_edges t f] iterates [f] on the edges of [t]. The edges are directed from each node towards
its subtrees. *)
val iter_edges : t -> (vertex * vertex -> unit) -> unit
end
(** [aldous_broder g v0 predicate] returns a uniform sampler
for spanning trees in the subgraph containing [v0]
and satisfying [predicate], using the Aldous-Broder algorithm. *)
val aldous_broder : t -> vertex -> (vertex -> bool) -> Tree.t Gen.t
end
(** Graph statistics generic on an undirected [Graph] implementation. *)
module Make (Graph : Stats_intf.Graph) :
Graph_statistics with type t = Graph.t and type vertex = Graph.vertex
| (** Basic statistics on graphs (experimental) *)
|
env_test.mli | (*_ This signature is deliberately empty. *)
| (*_ This signature is deliberately empty. *)
|
dune |
(library
(public_name carray)
(name carray)
(instrumentation
(backend bisect_ppx))
(library_flags :standard -linkall -ccopt -lpthread)
(foreign_stubs
(language c)
(names carray_stubs)))
(install
(files ocaml_carray.h)
(section lib)
(package carray))
| |
dune |
;
; We test in two phases:
;
; 1. Check that the generated Python code is what we expect.
;
(rule
(alias runtest)
(package atdpy)
(action
(diff python-expected/everything.py
python-tests/everything.py)))
; 2. Run the generated Python code and check that is reads or writes JSON
; data as expected.
;
; See python-tests/dune
| |
assert.ml | open Protocol
let error ~loc v f =
match v with
| Error err when List.exists f err -> return_unit
| Ok _ -> failwith "Unexpected successful result (%s)" loc
| Error err -> failwith "@[Unexpected error (%s): %a@]" loc pp_print_trace err
let test_error_encodings e =
let module E = Environment.Error_monad in
ignore (E.pp Format.str_formatter e) ;
let e' = E.json_of_error e |> E.error_of_json in
assert (e = e')
let proto_error ~loc v f =
error ~loc v (function
| Environment.Ecoproto_error err ->
test_error_encodings err ;
f err
| _ -> false)
let proto_error_with_info ~loc res error_title =
proto_error ~loc res (function err ->
error_title
= (Error_monad.find_info_of_error (Environment.wrap_tzerror err)).title)
let equal ~loc (cmp : 'a -> 'a -> bool) msg pp a b =
if not (cmp a b) then
failwith "@[@[[%s]@] - @[%s : %a is not equal to %a@]@]" loc msg pp a pp b
else return_unit
let leq ~loc (cmp : 'a -> 'a -> int) msg pp a b =
if cmp a b > 0 then
failwith
"@[@[[%s]@] - @[%s : %a is not less or equal to %a@]@]"
loc
msg
pp
a
pp
b
else return_unit
let lt ~loc (cmp : 'a -> 'a -> int) msg pp a b =
if cmp a b >= 0 then
failwith "@[@[[%s]@] - @[%s : %a is not less than %a@]@]" loc msg pp a pp b
else return_unit
let not_equal ~loc (cmp : 'a -> 'a -> bool) msg pp a b =
if cmp a b then
failwith "@[@[[%s]@] - @[%s : %a is equal to %a@]@]" loc msg pp a pp b
else return_unit
module Int32 = struct
include Int32
let pp pp v = Format.pp_print_int pp (Int32.to_int v)
end
module Int64 = struct
include Int64
let pp pp v = Format.pp_print_int pp (Int64.to_int v)
end
(* int *)
let equal_int ~loc (a : int) (b : int) =
equal ~loc Int.equal "Integers aren't equal" Format.pp_print_int a b
let not_equal_int ~loc (a : int) (b : int) =
not_equal ~loc Int.equal "Integers are equal" Format.pp_print_int a b
let leq_int ~loc (a : int) (b : int) =
leq ~loc Compare.Int.compare "Integer comparison" Format.pp_print_int a b
(* int32 *)
let equal_int32 ~loc (a : int32) (b : int32) =
equal ~loc Int32.equal "Int32 aren't equal" Int32.pp a b
let leq_int32 ~loc (a : int32) (b : int32) =
leq ~loc Compare.Int32.compare "Int32 comparison" Int32.pp a b
let lt_int32 ~loc (a : int32) (b : int32) =
lt ~loc Compare.Int32.compare "Int32 comparison" Int32.pp a b
(* int64 *)
let equal_int64 ~loc (a : int64) (b : int64) =
equal ~loc Compare.Int64.( = ) "Int64 aren't equal" Int64.pp a b
let not_equal_int64 ~loc (a : int64) (b : int64) =
not_equal ~loc Int64.equal "Int64 are equal" Int64.pp a b
let leq_int64 ~loc (a : int64) (b : int64) =
leq ~loc Compare.Int64.compare "Int64 comparison" Int64.pp a b
(* bool *)
let equal_bool ~loc (a : bool) (b : bool) =
equal ~loc Bool.equal "Booleans aren't equal" Format.pp_print_bool a b
let not_equal_bool ~loc (a : bool) (b : bool) =
not_equal ~loc Bool.equal "Booleans are equal" Format.pp_print_bool a b
(* string *)
let equal_string ~loc (a : string) (b : string) =
equal ~loc String.equal "Strings aren't equal" Format.pp_print_string a b
let not_equal_string ~loc (a : string) (b : string) =
not_equal ~loc String.equal "Strings are equal" Format.pp_print_string a b
(* tez *)
let equal_tez ~loc (a : Alpha_context.Tez.t) (b : Alpha_context.Tez.t) =
let open Alpha_context in
equal ~loc Tez.( = ) "Tez aren't equal" Tez.pp a b
let not_equal_tez ~loc (a : Alpha_context.Tez.t) (b : Alpha_context.Tez.t) =
let open Alpha_context in
not_equal ~loc Tez.( = ) "Tez are equal" Tez.pp a b
(* pkh *)
let equal_pkh ~loc (a : Signature.Public_key_hash.t)
(b : Signature.Public_key_hash.t) =
let module PKH = Signature.Public_key_hash in
equal ~loc PKH.equal "Public key hashes aren't equal" PKH.pp a b
let not_equal_pkh ~loc (a : Signature.Public_key_hash.t)
(b : Signature.Public_key_hash.t) =
let module PKH = Signature.Public_key_hash in
not_equal ~loc PKH.equal "Public key hashes are equal" PKH.pp a b
let get_some ~loc = function
| Some x -> return x
| None -> failwith "Unexpected None (%s)" loc
let is_none ~loc ~pp = function
| Some x -> failwith "Unexpected (Some %a) (%s)" pp x loc
| None -> return_unit
open Context
(* Some asserts for account operations *)
(** [balance_is b c amount] checks that the current balance of contract [c] is
[amount].
Default balance type is [Main], pass [~kind] with [Deposit], [Fees] or
[Rewards] for the others. *)
let balance_is ~loc b contract expected =
Contract.balance b contract >>=? fun balance ->
equal_tez ~loc balance expected
(** [balance_was_operated ~operand b c old_balance amount] checks that the
current balance of contract [c] is [operand old_balance amount] and
returns the current balance.
Default balance type is [Main], pass [~kind] with [Deposit], [Fees] or
[Rewards] for the others. *)
let balance_was_operated ~operand ~loc b contract old_balance amount =
operand old_balance amount |> Environment.wrap_tzresult >>?= fun expected ->
balance_is ~loc b contract expected
let balance_was_credited =
balance_was_operated ~operand:Alpha_context.Tez.( +? )
let balance_was_debited = balance_was_operated ~operand:Alpha_context.Tez.( -? )
let pp_print_list pp out xs =
let list_pp fmt =
Format.pp_print_list ~pp_sep:(fun fmt () -> Format.fprintf fmt ";@.") fmt
in
Format.fprintf out "[%a]" (list_pp pp) xs
let assert_equal_list ~loc eq msg pp =
equal ~loc (List.equal eq) msg (pp_print_list pp)
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2021-2022 Trili Tech, <contact@trili.tech> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
michelson_v1_macros.ml | open Protocol_client_context
open Tezos_micheline
open Micheline
module IntMap = Map.Make (Compare.Int)
type 'l node = ('l, string) Micheline.node
type error += Unexpected_macro_annotation of string
type error += Sequence_expected of string
type error += Invalid_arity of string * int * int
let rec check_letters str i j f =
i > j || (f str.[i] && check_letters str (i + 1) j f)
let expand_caddadr original =
match original with
| Prim (loc, str, args, annot) ->
let len = String.length str in
if
len > 3
&& str.[0] = 'C'
&& str.[len - 1] = 'R'
&& check_letters str 1 (len - 2) (function
| 'A' | 'D' -> true
| _ -> false)
then
(match args with
| [] -> ok ()
| _ :: _ -> error (Invalid_arity (str, List.length args, 0)))
>>? fun () ->
let path_annot =
List.filter (function "@%" | "@%%" -> true | _ -> false) annot
in
let rec parse i acc =
if i = 0 then Seq (loc, acc)
else
let annot = if i = len - 2 then annot else path_annot in
match str.[i] with
| 'A' -> parse (i - 1) (Prim (loc, "CAR", [], annot) :: acc)
| 'D' -> parse (i - 1) (Prim (loc, "CDR", [], annot) :: acc)
| _ -> assert false
in
ok (Some (parse (len - 2) []))
else ok None
| _ -> ok None
let expand_carn original =
match original with
| Prim (loc, "CAR", [Int (loc2, n)], annot) ->
ok
(Some
(Seq
( loc,
[
Prim
( loc,
"GET",
[Int (loc2, Z.(of_int 1 + (n * of_int 2)))],
annot );
] )))
| _ -> ok None
let expand_cdrn original =
match original with
| Prim (loc, "CDR", [Int (loc2, n)], annot) ->
ok
(Some
(Seq (loc, [Prim (loc, "GET", [Int (loc2, Z.(n * of_int 2))], annot)])))
| _ -> ok None
let extract_field_annots annot =
List.partition
(fun a ->
match a.[0] with
| '%' -> true
| _ -> false
| exception Invalid_argument _ -> false)
annot
let expand_set_caddadr original =
match original with
| Prim (loc, str, args, annot) ->
let len = String.length str in
if
len >= 7
&& String.sub str 0 5 = "SET_C"
&& str.[len - 1] = 'R'
&& check_letters str 5 (len - 2) (function
| 'A' | 'D' -> true
| _ -> false)
then
(match args with
| [] -> ok ()
| _ :: _ -> error (Invalid_arity (str, List.length args, 0)))
>>? fun () ->
(match extract_field_annots annot with
| ([], annot) -> ok (None, annot)
| ([f], annot) -> ok (Some f, annot)
| (_, _) -> error (Unexpected_macro_annotation str))
>>? fun (field_annot, annot) ->
let rec parse i acc =
if i = 4 then acc
else
let annot = if i = 5 then annot else [] in
match str.[i] with
| 'A' ->
let acc =
Seq
( loc,
[
Prim (loc, "DUP", [], []);
Prim
( loc,
"DIP",
[Seq (loc, [Prim (loc, "CAR", [], ["@%%"]); acc])],
[] );
Prim (loc, "CDR", [], ["@%%"]);
Prim (loc, "SWAP", [], []);
Prim (loc, "PAIR", [], "%@" :: "%@" :: annot);
] )
in
parse (i - 1) acc
| 'D' ->
let acc =
Seq
( loc,
[
Prim (loc, "DUP", [], []);
Prim
( loc,
"DIP",
[Seq (loc, [Prim (loc, "CDR", [], ["@%%"]); acc])],
[] );
Prim (loc, "CAR", [], ["@%%"]);
Prim (loc, "PAIR", [], "%@" :: "%@" :: annot);
] )
in
parse (i - 1) acc
| _ -> assert false
in
match str.[len - 2] with
| 'A' ->
let access_check =
match field_annot with
| None -> []
| Some f ->
[
Prim (loc, "DUP", [], []);
Prim (loc, "CAR", [], [f]);
Prim (loc, "DROP", [], []);
]
in
let encoding =
[Prim (loc, "CDR", [], ["@%%"]); Prim (loc, "SWAP", [], [])]
in
let pair =
[
Prim
( loc,
"PAIR",
[],
[Option.value field_annot ~default:"%"; "%@"] );
]
in
let init = Seq (loc, access_check @ encoding @ pair) in
ok (Some (parse (len - 3) init))
| 'D' ->
let access_check =
match field_annot with
| None -> []
| Some f ->
[
Prim (loc, "DUP", [], []);
Prim (loc, "CDR", [], [f]);
Prim (loc, "DROP", [], []);
]
in
let encoding = [Prim (loc, "CAR", [], ["@%%"])] in
let pair =
[
Prim
( loc,
"PAIR",
[],
["%@"; Option.value field_annot ~default:"%"] );
]
in
let init = Seq (loc, access_check @ encoding @ pair) in
ok (Some (parse (len - 3) init))
| _ -> assert false
else ok None
| _ -> ok None
let expand_map_caddadr original =
match original with
| Prim (loc, str, args, annot) ->
let len = String.length str in
if
len >= 7
&& String.sub str 0 5 = "MAP_C"
&& str.[len - 1] = 'R'
&& check_letters str 5 (len - 2) (function
| 'A' | 'D' -> true
| _ -> false)
then
(match args with
| [(Seq _ as code)] -> ok code
| [_] -> error (Sequence_expected str)
| [] | _ :: _ :: _ -> error (Invalid_arity (str, List.length args, 1)))
>>? fun code ->
(match extract_field_annots annot with
| ([], annot) -> ok (None, annot)
| ([f], annot) -> ok (Some f, annot)
| (_, _) -> error (Unexpected_macro_annotation str))
>>? fun (field_annot, annot) ->
let rec parse i acc =
if i = 4 then acc
else
let annot = if i = 5 then annot else [] in
match str.[i] with
| 'A' ->
let acc =
Seq
( loc,
[
Prim (loc, "DUP", [], []);
Prim
( loc,
"DIP",
[Seq (loc, [Prim (loc, "CAR", [], ["@%%"]); acc])],
[] );
Prim (loc, "CDR", [], ["@%%"]);
Prim (loc, "SWAP", [], []);
Prim (loc, "PAIR", [], "%@" :: "%@" :: annot);
] )
in
parse (i - 1) acc
| 'D' ->
let acc =
Seq
( loc,
[
Prim (loc, "DUP", [], []);
Prim
( loc,
"DIP",
[Seq (loc, [Prim (loc, "CDR", [], ["@%%"]); acc])],
[] );
Prim (loc, "CAR", [], ["@%%"]);
Prim (loc, "PAIR", [], "%@" :: "%@" :: annot);
] )
in
parse (i - 1) acc
| _ -> assert false
in
let cr_annot =
match field_annot with
| None -> []
| Some f -> ["@" ^ String.sub f 1 (String.length f - 1)]
in
match str.[len - 2] with
| 'A' ->
let init =
Seq
( loc,
[
Prim (loc, "DUP", [], []);
Prim (loc, "CDR", [], ["@%%"]);
Prim
( loc,
"DIP",
[Seq (loc, [Prim (loc, "CAR", [], cr_annot); code])],
[] );
Prim (loc, "SWAP", [], []);
Prim
( loc,
"PAIR",
[],
[Option.value field_annot ~default:"%"; "%@"] );
] )
in
ok (Some (parse (len - 3) init))
| 'D' ->
let init =
Seq
( loc,
[
Prim (loc, "DUP", [], []);
Prim (loc, "CDR", [], cr_annot);
code;
Prim (loc, "SWAP", [], []);
Prim (loc, "CAR", [], ["@%%"]);
Prim
( loc,
"PAIR",
[],
["%@"; Option.value field_annot ~default:"%"] );
] )
in
ok (Some (parse (len - 3) init))
| _ -> assert false
else ok None
| _ -> ok None
exception Not_a_roman
let decimal_of_roman roman =
(* http://rosettacode.org/wiki/Roman_numerals/Decode#OCaml *)
let arabic = ref 0 in
let lastval = ref 0 in
for i = String.length roman - 1 downto 0 do
let n =
match roman.[i] with
| 'M' -> 1000
| 'D' -> 500
| 'C' -> 100
| 'L' -> 50
| 'X' -> 10
| 'V' -> 5
| 'I' -> 1
| _ -> raise_notrace Not_a_roman
in
if Compare.Int.(n < !lastval) then arabic := !arabic - n
else arabic := !arabic + n ;
lastval := n
done ;
!arabic
let dip ~loc ?(annot = []) depth instr =
assert (depth >= 0) ;
if depth = 1 then Prim (loc, "DIP", [instr], annot)
else Prim (loc, "DIP", [Int (loc, Z.of_int depth); instr], annot)
let expand_deprecated_dxiiivp original =
(* transparently expands deprecated macro [DI...IP] to instruction [DIP n] *)
match original with
| Prim (loc, str, args, annot) ->
let len = String.length str in
if len > 3 && str.[0] = 'D' && str.[len - 1] = 'P' then
try
let depth = decimal_of_roman (String.sub str 1 (len - 2)) in
match args with
| [(Seq (_, _) as arg)] -> ok @@ Some (dip ~loc ~annot depth arg)
| [_] -> error (Sequence_expected str)
| [] | _ :: _ :: _ -> error (Invalid_arity (str, List.length args, 1))
with Not_a_roman -> ok None
else ok None
| _ -> ok None
exception Not_a_pair
type pair_item = A | I | P of int * pair_item * pair_item
let parse_pair_substr str ~len start =
let rec parse ?left i =
if i = len - 1 then raise_notrace Not_a_pair
else if str.[i] = 'P' then
let (next_i, l) = parse ~left:true (i + 1) in
let (next_i, r) = parse ~left:false next_i in
(next_i, P (i, l, r))
else if str.[i] = 'A' && left = Some true then (i + 1, A)
else if str.[i] = 'I' && left <> Some true then (i + 1, I)
else raise_notrace Not_a_pair
in
let (last, ast) = parse start in
if last <> len - 1 then raise_notrace Not_a_pair else ast
let unparse_pair_item ast =
let rec unparse ast acc =
match ast with
| P (_, l, r) -> unparse r (unparse l ("P" :: acc))
| A -> "A" :: acc
| I -> "I" :: acc
in
List.rev ("R" :: unparse ast []) |> String.concat ""
let pappaiir_annots_pos ast annot =
let rec find_annots_pos p_pos ast annots acc =
match (ast, annots) with
| (_, []) -> (annots, acc)
| (P (i, left, right), _) ->
let (annots, acc) = find_annots_pos i left annots acc in
find_annots_pos i right annots acc
| (A, a :: annots) ->
let pos =
match IntMap.find p_pos acc with
| None -> ([a], [])
| Some (_, cdr) -> ([a], cdr)
in
(annots, IntMap.add p_pos pos acc)
| (I, a :: annots) ->
let pos =
match IntMap.find p_pos acc with
| None -> ([], [a])
| Some (car, _) -> (car, [a])
in
(annots, IntMap.add p_pos pos acc)
in
snd (find_annots_pos 0 ast annot IntMap.empty)
let expand_pappaiir original =
match original with
| Prim (loc, str, args, annot) ->
let len = String.length str in
if
len > 4
&& str.[0] = 'P'
&& str.[len - 1] = 'R'
&& check_letters str 1 (len - 2) (function
| 'P' | 'A' | 'I' -> true
| _ -> false)
then
try
let (field_annots, annot) = extract_field_annots annot in
let ast = parse_pair_substr str ~len 0 in
let field_annots_pos = pappaiir_annots_pos ast field_annots in
let rec parse p (depth, acc) =
match p with
| P (i, left, right) ->
let annot =
match (i, IntMap.find i field_annots_pos) with
| (0, None) -> annot
| (_, None) -> []
| (0, Some ([], cdr_annot)) -> "%" :: cdr_annot @ annot
| (_, Some ([], cdr_annot)) -> "%" :: cdr_annot
| (0, Some (car_annot, cdr_annot)) ->
car_annot @ cdr_annot @ annot
| (_, Some (car_annot, cdr_annot)) -> car_annot @ cdr_annot
in
let acc =
if depth = 0 then Prim (loc, "PAIR", [], annot) :: acc
else
dip ~loc depth (Seq (loc, [Prim (loc, "PAIR", [], annot)]))
:: acc
in
(depth, acc) |> parse left |> parse right
| A | I -> (depth + 1, acc)
in
let (_, expanded) = parse ast (0, []) in
(match args with
| [] -> ok ()
| _ :: _ -> error (Invalid_arity (str, List.length args, 0)))
>>? fun () -> ok (Some (Seq (loc, expanded)))
with Not_a_pair -> ok None
else ok None
| _ -> ok None
let expand_unpappaiir original =
match original with
| Prim (loc, str, args, _annot) ->
let len = String.length str in
if
len > 6
&& String.sub str 0 3 = "UNP"
&& str.[len - 1] = 'R'
&& check_letters str 3 (len - 2) (function
| 'P' | 'A' | 'I' -> true
| _ -> false)
then
try
let unpair = Prim (loc, "UNPAIR", [], []) in
let ast = parse_pair_substr str ~len 2 in
let rec parse p (depth, acc) =
match p with
| P (_i, left, right) ->
let acc =
if depth = 0 then unpair :: acc
else dip ~loc depth (Seq (loc, [unpair])) :: acc
in
(depth, acc) |> parse left |> parse right
| A | I -> (depth + 1, acc)
in
let (_, rev_expanded) = parse ast (0, []) in
let expanded = Seq (loc, List.rev rev_expanded) in
(match args with
| [] -> ok ()
| _ :: _ -> error (Invalid_arity (str, List.length args, 0)))
>>? fun () -> ok (Some expanded)
with Not_a_pair -> ok None
else ok None
| _ -> ok None
exception Not_a_dup
let expand_deprecated_duuuuup original =
(* transparently expands deprecated macro [DU...UP] to [{ DUP n }] *)
match original with
| Prim (loc, str, args, annot) ->
let len = String.length str in
if
len > 3
&& str.[0] = 'D'
&& str.[len - 1] = 'P'
&& check_letters str 1 (len - 2) (( = ) 'U')
then
(match args with
| [] -> ok ()
| _ :: _ -> error (Invalid_arity (str, List.length args, 0)))
>>? fun () ->
try
let rec parse i =
if i = 1 then
Prim (loc, "DUP", [Int (loc, Z.of_int (len - 2))], annot)
else if str.[i] = 'U' then parse (i - 1)
else raise_notrace Not_a_dup
in
ok (Some (parse (len - 2)))
with Not_a_dup -> ok None
else ok None
| _ -> ok None
let expand_compare original =
let cmp loc is annot =
let is =
match List.rev_map (fun i -> Prim (loc, i, [], [])) is with
| Prim (loc, i, args, _) :: r ->
List.rev (Prim (loc, i, args, annot) :: r)
| is -> List.rev is
in
ok (Some (Seq (loc, is)))
in
let ifcmp loc is l r annot =
let is =
List.map (fun i -> Prim (loc, i, [], [])) is
@ [Prim (loc, "IF", [l; r], annot)]
in
ok (Some (Seq (loc, is)))
in
match original with
| Prim (loc, "CMPEQ", [], annot) -> cmp loc ["COMPARE"; "EQ"] annot
| Prim (loc, "CMPNEQ", [], annot) -> cmp loc ["COMPARE"; "NEQ"] annot
| Prim (loc, "CMPLT", [], annot) -> cmp loc ["COMPARE"; "LT"] annot
| Prim (loc, "CMPGT", [], annot) -> cmp loc ["COMPARE"; "GT"] annot
| Prim (loc, "CMPLE", [], annot) -> cmp loc ["COMPARE"; "LE"] annot
| Prim (loc, "CMPGE", [], annot) -> cmp loc ["COMPARE"; "GE"] annot
| Prim
( _,
(("CMPEQ" | "CMPNEQ" | "CMPLT" | "CMPGT" | "CMPLE" | "CMPGE") as str),
args,
[] ) ->
error (Invalid_arity (str, List.length args, 0))
| Prim (loc, "IFCMPEQ", [l; r], annot) ->
ifcmp loc ["COMPARE"; "EQ"] l r annot
| Prim (loc, "IFCMPNEQ", [l; r], annot) ->
ifcmp loc ["COMPARE"; "NEQ"] l r annot
| Prim (loc, "IFCMPLT", [l; r], annot) ->
ifcmp loc ["COMPARE"; "LT"] l r annot
| Prim (loc, "IFCMPGT", [l; r], annot) ->
ifcmp loc ["COMPARE"; "GT"] l r annot
| Prim (loc, "IFCMPLE", [l; r], annot) ->
ifcmp loc ["COMPARE"; "LE"] l r annot
| Prim (loc, "IFCMPGE", [l; r], annot) ->
ifcmp loc ["COMPARE"; "GE"] l r annot
| Prim (loc, "IFEQ", [l; r], annot) -> ifcmp loc ["EQ"] l r annot
| Prim (loc, "IFNEQ", [l; r], annot) -> ifcmp loc ["NEQ"] l r annot
| Prim (loc, "IFLT", [l; r], annot) -> ifcmp loc ["LT"] l r annot
| Prim (loc, "IFGT", [l; r], annot) -> ifcmp loc ["GT"] l r annot
| Prim (loc, "IFLE", [l; r], annot) -> ifcmp loc ["LE"] l r annot
| Prim (loc, "IFGE", [l; r], annot) -> ifcmp loc ["GE"] l r annot
| Prim
( _,
(( "IFCMPEQ" | "IFCMPNEQ" | "IFCMPLT" | "IFCMPGT" | "IFCMPLE"
| "IFCMPGE" | "IFEQ" | "IFNEQ" | "IFLT" | "IFGT" | "IFLE" | "IFGE" ) as
str),
args,
[] ) ->
error (Invalid_arity (str, List.length args, 2))
| Prim
( _,
(( "IFCMPEQ" | "IFCMPNEQ" | "IFCMPLT" | "IFCMPGT" | "IFCMPLE"
| "IFCMPGE" | "IFEQ" | "IFNEQ" | "IFLT" | "IFGT" | "IFLE" | "IFGE" ) as
str),
[],
_ :: _ ) ->
error (Unexpected_macro_annotation str)
| _ -> ok None
let expand_asserts original =
let may_rename loc = function
| [] -> Seq (loc, [])
| annot -> Seq (loc, [Prim (loc, "RENAME", [], annot)])
in
let fail_false ?(annot = []) loc =
[may_rename loc annot; Seq (loc, [Prim (loc, "FAIL", [], [])])]
in
let fail_true ?(annot = []) loc =
[Seq (loc, [Prim (loc, "FAIL", [], [])]); may_rename loc annot]
in
match original with
| Prim (loc, "ASSERT", [], []) ->
ok @@ Some (Seq (loc, [Prim (loc, "IF", fail_false loc, [])]))
| Prim (loc, "ASSERT_NONE", [], []) ->
ok @@ Some (Seq (loc, [Prim (loc, "IF_NONE", fail_false loc, [])]))
| Prim (loc, "ASSERT_SOME", [], annot) ->
ok @@ Some (Seq (loc, [Prim (loc, "IF_NONE", fail_true ~annot loc, [])]))
| Prim (loc, "ASSERT_LEFT", [], annot) ->
ok @@ Some (Seq (loc, [Prim (loc, "IF_LEFT", fail_false ~annot loc, [])]))
| Prim (loc, "ASSERT_RIGHT", [], annot) ->
ok @@ Some (Seq (loc, [Prim (loc, "IF_LEFT", fail_true ~annot loc, [])]))
| Prim
( _,
(( "ASSERT" | "ASSERT_NONE" | "ASSERT_SOME" | "ASSERT_LEFT"
| "ASSERT_RIGHT" ) as str),
args,
[] ) ->
error (Invalid_arity (str, List.length args, 0))
| Prim (_, (("ASSERT" | "ASSERT_NONE") as str), [], _ :: _) ->
error (Unexpected_macro_annotation str)
| Prim (loc, s, args, annot)
when String.(length s > 7 && equal (sub s 0 7) "ASSERT_") -> (
(match args with
| [] -> ok ()
| _ :: _ -> error (Invalid_arity (s, List.length args, 0)))
>>? fun () ->
(match annot with
| _ :: _ -> error (Unexpected_macro_annotation s)
| [] -> ok ())
>>? fun () ->
let remaining = String.(sub s 7 (length s - 7)) in
let remaining_prim = Prim (loc, remaining, [], []) in
match remaining with
| "EQ" | "NEQ" | "LT" | "LE" | "GE" | "GT" ->
ok
@@ Some
(Seq (loc, [remaining_prim; Prim (loc, "IF", fail_false loc, [])]))
| _ -> (
expand_compare remaining_prim >|? function
| None -> None
| Some seq ->
Some (Seq (loc, [seq; Prim (loc, "IF", fail_false loc, [])]))))
| _ -> ok None
let expand_if_some = function
| Prim (loc, "IF_SOME", [right; left], annot) ->
ok @@ Some (Seq (loc, [Prim (loc, "IF_NONE", [left; right], annot)]))
| Prim (_, "IF_SOME", args, _annot) ->
error (Invalid_arity ("IF_SOME", List.length args, 2))
| _ -> ok @@ None
let expand_if_right = function
| Prim (loc, "IF_RIGHT", [right; left], annot) ->
ok @@ Some (Seq (loc, [Prim (loc, "IF_LEFT", [left; right], annot)]))
| Prim (_, "IF_RIGHT", args, _annot) ->
error (Invalid_arity ("IF_RIGHT", List.length args, 2))
| _ -> ok @@ None
let expand_fail = function
| Prim (loc, "FAIL", [], []) ->
ok
@@ Some
(Seq
(loc, [Prim (loc, "UNIT", [], []); Prim (loc, "FAILWITH", [], [])]))
| _ -> ok @@ None
let expand original =
let rec try_expansions = function
| [] -> ok @@ original
| expander :: expanders -> (
expander original >>? function
| None -> try_expansions expanders
| Some rewritten -> ok rewritten)
in
try_expansions
[
expand_carn;
expand_cdrn;
expand_caddadr;
expand_set_caddadr;
expand_map_caddadr;
expand_deprecated_dxiiivp;
(* expand_paaiair ; *)
expand_pappaiir;
(* expand_unpaaiair ; *)
expand_unpappaiir;
expand_deprecated_duuuuup;
expand_compare;
expand_asserts;
expand_if_some;
expand_if_right;
expand_fail;
]
let expand_rec expr =
let rec error_map (expanded, errors) f = function
| [] -> (List.rev expanded, List.rev errors)
| hd :: tl ->
let (new_expanded, new_errors) = f hd in
error_map
(new_expanded :: expanded, List.rev_append new_errors errors)
f
tl
in
let error_map = error_map ([], []) in
let rec expand_rec expr =
match expand expr with
| Ok expanded -> (
match expanded with
| Seq (loc, items) ->
let (items, errors) = error_map expand_rec items in
(Seq (loc, items), errors)
| Prim (loc, name, args, annot) ->
let (args, errors) = error_map expand_rec args in
(Prim (loc, name, args, annot), errors)
| (Int _ | String _ | Bytes _) as atom -> (atom, []))
| Error errors -> (expr, errors)
in
expand_rec expr
let unexpand_carn_and_cdrn expanded =
match expanded with
| Seq (loc, [Prim (_, "GET", [Int (locn, n)], annot)]) ->
let (half, parity) = Z.ediv_rem n (Z.of_int 2) in
if Z.(parity = zero) then
Some (Prim (loc, "CDR", [Int (locn, half)], annot))
else Some (Prim (loc, "CAR", [Int (locn, half)], annot))
| _ -> None
let unexpand_caddadr expanded =
let rec rsteps acc = function
| [] -> Some acc
| Prim (_, "CAR", [], []) :: rest -> rsteps ("A" :: acc) rest
| Prim (_, "CDR", [], []) :: rest -> rsteps ("D" :: acc) rest
| _ -> None
in
match expanded with
| Seq (loc, (Prim (_, "CAR", [], []) :: _ as nodes))
| Seq (loc, (Prim (_, "CDR", [], []) :: _ as nodes)) -> (
match rsteps [] nodes with
| Some steps ->
let name = String.concat "" ("C" :: List.rev ("R" :: steps)) in
Some (Prim (loc, name, [], []))
| None -> None)
| _ -> None
let unexpand_set_caddadr expanded =
let rec steps acc annots = function
| Seq
( loc,
[
Prim (_, "CDR", [], _);
Prim (_, "SWAP", [], _);
Prim (_, "PAIR", [], _);
] ) ->
Some (loc, "A" :: acc, annots)
| Seq
( loc,
[
Prim (_, "DUP", [], []);
Prim (_, "CAR", [], [field_annot]);
Prim (_, "DROP", [], []);
Prim (_, "CDR", [], _);
Prim (_, "SWAP", [], []);
Prim (_, "PAIR", [], _);
] ) ->
Some (loc, "A" :: acc, field_annot :: annots)
| Seq (loc, [Prim (_, "CAR", [], _); Prim (_, "PAIR", [], _)]) ->
Some (loc, "D" :: acc, annots)
| Seq
( loc,
[
Prim (_, "DUP", [], []);
Prim (_, "CDR", [], [field_annot]);
Prim (_, "DROP", [], []);
Prim (_, "CAR", [], _);
Prim (_, "PAIR", [], _);
] ) ->
Some (loc, "D" :: acc, field_annot :: annots)
| Seq
( _,
[
Prim (_, "DUP", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CAR", [], _); sub])], []);
Prim (_, "CDR", [], _);
Prim (_, "SWAP", [], []);
Prim (_, "PAIR", [], pair_annots);
] ) ->
let (_, pair_annots) = extract_field_annots pair_annots in
steps ("A" :: acc) (List.rev_append pair_annots annots) sub
| Seq
( _,
[
Prim (_, "DUP", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CDR", [], _); sub])], []);
Prim (_, "CAR", [], _);
Prim (_, "PAIR", [], pair_annots);
] ) ->
let (_, pair_annots) = extract_field_annots pair_annots in
steps ("D" :: acc) (List.rev_append pair_annots annots) sub
| _ -> None
in
match steps [] [] expanded with
| Some (loc, steps, annots) ->
let name = String.concat "" ("SET_C" :: List.rev ("R" :: steps)) in
Some (Prim (loc, name, [], List.rev annots))
| None -> None
let unexpand_map_caddadr expanded =
let rec steps acc annots = function
| Seq
( loc,
[
Prim (_, "DUP", [], []);
Prim (_, "CDR", [], _);
Prim (_, "SWAP", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CAR", [], []); code])], []);
Prim (_, "PAIR", [], _);
] ) ->
Some (loc, "A" :: acc, annots, code)
| Seq
( loc,
[
Prim (_, "DUP", [], []);
Prim (_, "CDR", [], _);
Prim (_, "SWAP", [], []);
Prim
( _,
"DIP",
[Seq (_, [Prim (_, "CAR", [], [field_annot]); code])],
[] );
Prim (_, "PAIR", [], _);
] ) ->
Some (loc, "A" :: acc, field_annot :: annots, code)
| Seq
( loc,
[
Prim (_, "DUP", [], []);
Prim (_, "CDR", [], []);
code;
Prim (_, "SWAP", [], []);
Prim (_, "CAR", [], _);
Prim (_, "PAIR", [], _);
] ) ->
Some (loc, "D" :: acc, annots, code)
| Seq
( loc,
[
Prim (_, "DUP", [], []);
Prim (_, "CDR", [], [field_annot]);
code;
Prim (_, "SWAP", [], []);
Prim (_, "CAR", [], _);
Prim (_, "PAIR", [], _);
] ) ->
Some (loc, "D" :: acc, field_annot :: annots, code)
| Seq
( _,
[
Prim (_, "DUP", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CAR", [], _); sub])], []);
Prim (_, "CDR", [], _);
Prim (_, "SWAP", [], []);
Prim (_, "PAIR", [], pair_annots);
] ) ->
let (_, pair_annots) = extract_field_annots pair_annots in
steps ("A" :: acc) (List.rev_append pair_annots annots) sub
| Seq
( _,
[
Prim (_, "DUP", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CDR", [], []); sub])], []);
Prim (_, "CAR", [], []);
Prim (_, "PAIR", [], pair_annots);
] ) ->
let (_, pair_annots) = extract_field_annots pair_annots in
steps ("D" :: acc) (List.rev_append pair_annots annots) sub
| _ -> None
in
match steps [] [] expanded with
| Some (loc, steps, annots, code) ->
let name = String.concat "" ("MAP_C" :: List.rev ("R" :: steps)) in
Some (Prim (loc, name, [code], List.rev annots))
| None -> None
let unexpand_deprecated_dxiiivp expanded =
(* transparently turn the old expansion of deprecated [DI...IP] to [DIP n] *)
match expanded with
| Seq
( loc,
[Prim (_, "DIP", [(Seq (_, [Prim (_, "DIP", [_], [])]) as sub)], [])] )
->
let rec count acc = function
| Seq (_, [Prim (_, "DIP", [sub], [])]) -> count (acc + 1) sub
| sub -> (acc, sub)
in
let (depth, sub) = count 1 sub in
Some (Prim (loc, "DIP", [Int (loc, Z.of_int depth); sub], []))
| _ -> None
let unexpand_dupn expanded =
match expanded with
| Seq
( loc,
[
Prim
(_, "DIP", [Int (_, np); Seq (_, [Prim (_, "DUP", [], annot)])], []);
Prim (_, "DIG", [Int (nloc, ng)], []);
] )
when Z.equal np (Z.pred ng) ->
Some (Prim (loc, "DUP", [Int (nloc, ng)], annot))
| _ -> None
let unexpand_deprecated_duuuuup expanded =
(* transparently turn the old expansion of deprecated [DU...UP] to [DUP n] *)
let rec expand n = function
| Seq (loc, [Prim (nloc, "DUP", [], annot)]) ->
if n = 1 then None
else Some (Prim (loc, "DUP", [Int (nloc, Z.of_int n)], annot))
| Seq (_, [Prim (_, "DIP", [expanded'], []); Prim (_, "SWAP", [], [])]) ->
expand (n + 1) expanded'
| _ -> None
in
expand 1 expanded
let rec normalize_pair_item ?(right = false) = function
| P (i, a, b) ->
P (i, normalize_pair_item a, normalize_pair_item ~right:true b)
| A when right -> I
| A -> A
| I -> I
let unexpand_pappaiir expanded =
match expanded with
| Seq (_, [Prim (_, "PAIR", [], [])]) -> Some expanded
| Seq (loc, (_ :: _ as nodes)) -> (
let rec exec stack nodes =
match (nodes, stack) with
| ([], _) -> stack
(* support new expansion using [DIP n] *)
| ( Prim (ploc, "DIP", [Int (loc, n); Seq (sloc, sub)], []) :: rest,
a :: rstack )
when Z.to_int n > 1 ->
exec
(a
::
exec
rstack
[
Prim (ploc, "DIP", [Int (loc, Z.pred n); Seq (sloc, sub)], []);
])
rest
| (Prim (_, "DIP", [Int (_, n); Seq (_, sub)], []) :: rest, a :: rstack)
when Z.to_int n = 1 ->
exec (a :: exec rstack sub) rest
| (Prim (ploc, "DIP", [Int (loc, n); Seq (sloc, sub)], []) :: rest, [])
when Z.to_int n > 1 ->
exec
(A
::
exec
[]
[
Prim (ploc, "DIP", [Int (loc, Z.pred n); Seq (sloc, sub)], []);
])
rest
| (Prim (_, "DIP", [Int (_, n); Seq (_, sub)], []) :: rest, [])
when Z.to_int n = 1 ->
exec (A :: exec [] sub) rest
(* support old expansion using [DIP] *)
| (Prim (_, "DIP", [Seq (_, sub)], []) :: rest, a :: rstack) ->
exec (a :: exec rstack sub) rest
| (Prim (_, "DIP", [Seq (_, sub)], []) :: rest, []) ->
exec (A :: exec [] sub) rest
| (Prim (_, "PAIR", [], []) :: rest, a :: b :: rstack) ->
exec (P (0, a, b) :: rstack) rest
| (Prim (_, "PAIR", [], []) :: rest, [a]) -> exec [P (0, a, I)] rest
| (Prim (_, "PAIR", [], []) :: rest, []) -> exec [P (0, A, I)] rest
| _ -> raise_notrace Not_a_pair
in
match exec [] nodes with
| [] -> None
| res :: _ ->
let res = normalize_pair_item res in
let name = unparse_pair_item res in
Some (Prim (loc, name, [], []))
| exception Not_a_pair -> None)
| _ -> None
let unexpand_unpappaiir expanded =
match expanded with
| Seq (loc, (_ :: _ as nodes)) -> (
let rec exec stack nodes =
match (nodes, stack) with
| ([], _) -> stack
(* support new expansion using [DIP n] *)
| ( Prim (ploc, "DIP", [Int (loc, n); Seq (sloc, sub)], []) :: rest,
a :: rstack )
when Z.to_int n > 1 ->
exec
(a
::
exec
rstack
[
Prim (ploc, "DIP", [Int (loc, Z.pred n); Seq (sloc, sub)], []);
])
rest
| (Prim (_, "DIP", [Int (_, n); Seq (_, sub)], []) :: rest, a :: rstack)
when Z.to_int n = 1 ->
exec (a :: exec rstack sub) rest
| (Prim (ploc, "DIP", [Int (loc, n); Seq (sloc, sub)], []) :: rest, [])
when Z.to_int n > 1 ->
exec
(A
::
exec
[]
[
Prim (ploc, "DIP", [Int (loc, Z.pred n); Seq (sloc, sub)], []);
])
rest
| (Prim (_, "DIP", [Int (_, n); Seq (_, sub)], []) :: rest, [])
when Z.to_int n = 1 ->
exec (A :: exec [] sub) rest
(* support old expansion using [DIP] *)
| (Prim (_, "DIP", [Seq (_, sub)], []) :: rest, a :: rstack) ->
exec (a :: exec rstack sub) rest
| (Prim (_, "DIP", [Seq (_, sub)], []) :: rest, []) ->
exec (A :: exec [] sub) rest
| ( Seq
( _,
[
Prim (_, "DUP", [], []);
Prim (_, "CAR", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CDR", [], [])])], []);
] )
:: rest,
a :: b :: rstack ) ->
exec (P (0, a, b) :: rstack) rest
| ( Seq
( _,
[
Prim (_, "DUP", [], []);
Prim (_, "CAR", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CDR", [], [])])], []);
] )
:: rest,
[a] ) ->
exec [P (0, a, I)] rest
| ( Seq
( _,
[
Prim (_, "DUP", [], []);
Prim (_, "CAR", [], []);
Prim (_, "DIP", [Seq (_, [Prim (_, "CDR", [], [])])], []);
] )
:: rest,
[] ) ->
exec [P (0, A, I)] rest
| _ -> raise_notrace Not_a_pair
in
match exec [] (List.rev nodes) with
| [] -> None
| res :: _ ->
let res = normalize_pair_item res in
let name = "UN" ^ unparse_pair_item res in
Some (Prim (loc, name, [], []))
| exception Not_a_pair -> None)
| _ -> None
let unexpand_compare expanded =
match expanded with
| Seq (loc, [Prim (_, "COMPARE", [], _); Prim (_, "EQ", [], annot)]) ->
Some (Prim (loc, "CMPEQ", [], annot))
| Seq (loc, [Prim (_, "COMPARE", [], _); Prim (_, "NEQ", [], annot)]) ->
Some (Prim (loc, "CMPNEQ", [], annot))
| Seq (loc, [Prim (_, "COMPARE", [], _); Prim (_, "LT", [], annot)]) ->
Some (Prim (loc, "CMPLT", [], annot))
| Seq (loc, [Prim (_, "COMPARE", [], _); Prim (_, "GT", [], annot)]) ->
Some (Prim (loc, "CMPGT", [], annot))
| Seq (loc, [Prim (_, "COMPARE", [], _); Prim (_, "LE", [], annot)]) ->
Some (Prim (loc, "CMPLE", [], annot))
| Seq (loc, [Prim (_, "COMPARE", [], _); Prim (_, "GE", [], annot)]) ->
Some (Prim (loc, "CMPGE", [], annot))
| Seq
( loc,
[
Prim (_, "COMPARE", [], _);
Prim (_, "EQ", [], _);
Prim (_, "IF", args, annot);
] ) ->
Some (Prim (loc, "IFCMPEQ", args, annot))
| Seq
( loc,
[
Prim (_, "COMPARE", [], _);
Prim (_, "NEQ", [], _);
Prim (_, "IF", args, annot);
] ) ->
Some (Prim (loc, "IFCMPNEQ", args, annot))
| Seq
( loc,
[
Prim (_, "COMPARE", [], _);
Prim (_, "LT", [], _);
Prim (_, "IF", args, annot);
] ) ->
Some (Prim (loc, "IFCMPLT", args, annot))
| Seq
( loc,
[
Prim (_, "COMPARE", [], _);
Prim (_, "GT", [], _);
Prim (_, "IF", args, annot);
] ) ->
Some (Prim (loc, "IFCMPGT", args, annot))
| Seq
( loc,
[
Prim (_, "COMPARE", [], _);
Prim (_, "LE", [], _);
Prim (_, "IF", args, annot);
] ) ->
Some (Prim (loc, "IFCMPLE", args, annot))
| Seq
( loc,
[
Prim (_, "COMPARE", [], _);
Prim (_, "GE", [], _);
Prim (_, "IF", args, annot);
] ) ->
Some (Prim (loc, "IFCMPGE", args, annot))
| Seq (loc, [Prim (_, "EQ", [], _); Prim (_, "IF", args, annot)]) ->
Some (Prim (loc, "IFEQ", args, annot))
| Seq (loc, [Prim (_, "NEQ", [], _); Prim (_, "IF", args, annot)]) ->
Some (Prim (loc, "IFNEQ", args, annot))
| Seq (loc, [Prim (_, "LT", [], _); Prim (_, "IF", args, annot)]) ->
Some (Prim (loc, "IFLT", args, annot))
| Seq (loc, [Prim (_, "GT", [], _); Prim (_, "IF", args, annot)]) ->
Some (Prim (loc, "IFGT", args, annot))
| Seq (loc, [Prim (_, "LE", [], _); Prim (_, "IF", args, annot)]) ->
Some (Prim (loc, "IFLE", args, annot))
| Seq (loc, [Prim (_, "GE", [], _); Prim (_, "IF", args, annot)]) ->
Some (Prim (loc, "IFGE", args, annot))
| _ -> None
let unexpand_asserts expanded =
match expanded with
| Seq
( loc,
[
Prim
( _,
"IF",
[
Seq (_, []);
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
],
[] );
] ) ->
Some (Prim (loc, "ASSERT", [], []))
| Seq
( loc,
[
Seq (_, [Prim (_, "COMPARE", [], []); Prim (_, comparison, [], [])]);
Prim
( _,
"IF",
[
Seq (_, []);
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_CMP" ^ comparison, [], []))
| Seq
( loc,
[
Prim (_, comparison, [], []);
Prim
( _,
"IF",
[
Seq (_, []);
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_" ^ comparison, [], []))
| Seq
( loc,
[
Prim
( _,
"IF_NONE",
[
Seq (_, [Prim (_, "RENAME", [], annot)]);
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_NONE", [], annot))
| Seq
( loc,
[
Prim
( _,
"IF_NONE",
[
Seq (_, []);
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_NONE", [], []))
| Seq
( loc,
[
Prim
( _,
"IF_NONE",
[
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
Seq (_, []);
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_SOME", [], []))
| Seq
( loc,
[
Prim
( _,
"IF_NONE",
[
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
Seq (_, [Prim (_, "RENAME", [], annot)]);
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_SOME", [], annot))
| Seq
( loc,
[
Prim
( _,
"IF_LEFT",
[
Seq (_, []);
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_LEFT", [], []))
| Seq
( loc,
[
Prim
( _,
"IF_LEFT",
[
Seq (_, [Prim (_, "RENAME", [], annot)]);
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_LEFT", [], annot))
| Seq
( loc,
[
Prim
( _,
"IF_LEFT",
[
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
Seq (_, []);
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_RIGHT", [], []))
| Seq
( loc,
[
Prim
( _,
"IF_LEFT",
[
Seq
( _,
[
Seq
( _,
[
Prim (_, "UNIT", [], []);
Prim (_, "FAILWITH", [], []);
] );
] );
Seq (_, [Prim (_, "RENAME", [], annot)]);
],
[] );
] ) ->
Some (Prim (loc, "ASSERT_RIGHT", [], annot))
| _ -> None
let unexpand_if_some = function
| Seq (loc, [Prim (_, "IF_NONE", [left; right], annot)]) ->
Some (Prim (loc, "IF_SOME", [right; left], annot))
| _ -> None
let unexpand_if_right = function
| Seq (loc, [Prim (_, "IF_LEFT", [left; right], annot)]) ->
Some (Prim (loc, "IF_RIGHT", [right; left], annot))
| _ -> None
let unexpand_fail = function
| Seq (loc, [Prim (_, "UNIT", [], []); Prim (_, "FAILWITH", [], [])]) ->
Some (Prim (loc, "FAIL", [], []))
| _ -> None
let unexpand original =
let try_unexpansions unexpanders =
Option.value
~default:original
(List.fold_left
(fun acc f -> Option.either_f acc (fun () -> f original))
None
unexpanders)
in
try_unexpansions
[
unexpand_asserts;
unexpand_carn_and_cdrn;
unexpand_caddadr;
unexpand_set_caddadr;
unexpand_map_caddadr;
unexpand_deprecated_dxiiivp;
unexpand_pappaiir;
unexpand_unpappaiir;
unexpand_deprecated_duuuuup;
unexpand_dupn;
unexpand_compare;
unexpand_if_some;
unexpand_if_right;
unexpand_fail;
]
(*
If an argument of Prim is a sequence, we do not want to unexpand
its root in case the source already contains an expanded macro. In
which case unexpansion would remove surrounding braces and generate
ill-formed code.
For example, DIIP { DIP { DUP }; SWAP } is not unexpandable but
DIIP {{ DIP { DUP }; SWAP }} (note the double braces) is unexpanded
to DIIP { DUUP }.
unexpand_rec_but_root is the same as unexpand_rec but does not try
to unexpand at root *)
let rec unexpand_rec expr = unexpand_rec_but_root (unexpand expr)
and unexpand_rec_but_root = function
| Seq (loc, items) -> Seq (loc, List.map unexpand_rec items)
| Prim (loc, name, args, annot) ->
Prim (loc, name, List.map unexpand_rec_but_root args, annot)
| (Int _ | String _ | Bytes _) as atom -> atom
let () =
let open Data_encoding in
register_error_kind
`Permanent
~id:"michelson.macros.unexpected_annotation"
~title:"Unexpected annotation"
~description:
"A macro had an annotation, but no annotation was permitted on this \
macro."
~pp:(fun ppf -> Format.fprintf ppf "Unexpected annotation on macro %s.")
(obj1 (req "macro_name" string))
(function Unexpected_macro_annotation str -> Some str | _ -> None)
(fun s -> Unexpected_macro_annotation s) ;
register_error_kind
`Permanent
~id:"michelson.macros.sequence_expected"
~title:"Macro expects a sequence"
~description:"An macro expects a sequence, but a sequence was not provided"
~pp:(fun ppf name ->
Format.fprintf
ppf
"Macro %s expects a sequence, but did not receive one."
name)
(obj1 (req "macro_name" string))
(function Sequence_expected name -> Some name | _ -> None)
(fun name -> Sequence_expected name) ;
register_error_kind
`Permanent
~id:"michelson.macros.bas_arity"
~title:"Wrong number of arguments to macro"
~description:"A wrong number of arguments was provided to a macro"
~pp:(fun ppf (name, got, exp) ->
Format.fprintf
ppf
"Macro %s expects %d arguments, was given %d."
name
exp
got)
(obj3
(req "macro_name" string)
(req "given_number_of_arguments" uint16)
(req "expected_number_of_arguments" uint16))
(function
| Invalid_arity (name, got, exp) -> Some (name, got, exp) | _ -> None)
(fun (name, got, exp) -> Invalid_arity (name, got, exp))
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2019 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
test_numeric.ml |
open OUnit2
open Mirage_crypto.Uncommon
open Mirage_crypto_pk
open Test_common
let n_encode_decode_selftest ~typ ~bound n =
typ ^ "selftest" >:: times ~n @@ fun _ ->
let r = Z_extra.gen bound in
let s = Z_extra.(of_cstruct_be @@ to_cstruct_be r)
and t = Z_extra.(of_cstruct_be @@ to_cstruct_be ~size:24 r) in
assert_equal r s;
assert_equal r t
let n_decode_reencode_selftest ~typ ~bytes n =
typ ^ " selftest" >:: times ~n @@ fun _ ->
let cs = Mirage_crypto_rng.generate bytes in
let cs' = Z_extra.(to_cstruct_be ~size:bytes @@ of_cstruct_be cs) in
assert_cs_equal cs cs'
let random_n_selftest ~typ n bounds =
typ ^ " selftest" >::: (
bounds |> List.map @@ fun (lo, hi) ->
"selftest" >:: times ~n @@ fun _ ->
let x = Z_extra.gen_r lo hi in
if x < lo || x >= hi then assert_failure "range error"
)
let int_safe_bytes = Sys.word_size // 8 - 1
let suite = [
"Numeric extraction 1" >::: [
n_encode_decode_selftest
~typ:"z" ~bound:Z.(of_int64 Int64.max_int) 2000 ;
] ;
"Numeric extraction 2" >::: [
n_decode_reencode_selftest ~typ:"z" ~bytes:37 2000 ;
];
"RNG extraction" >::: [
random_n_selftest ~typ:"Z" 1000 [
Z.(of_int 7, of_int 135);
Z.(of_int 0, of_int 536870913);
Z.(of_int 0, of_int64 2305843009213693953L)
] ;
]
]
| |
test_sexp.ml |
let files =
[
"anchor.yml";
"cohttp.yml";
"linuxkit.yml";
"seq.yml";
"too_large.yml";
"yaml-1.2.yml";
]
let dir f = Fpath.(v "yaml" / f)
let all_files = List.map dir ("bomb.yml" :: files)
let all_simple_files = List.map dir files
type error = [ `Msg of string ]
let pp_error ppf (`Msg x) = Fmt.string ppf x
let error = Alcotest.testable pp_error ( = )
let t = Alcotest.(result unit error)
let value = Alcotest.testable Yaml.pp Yaml.equal
let check_file f fn =
let name = Fpath.to_string f in
let test () = Alcotest.check t name (Ok ()) (fn f) in
(name, `Quick, test)
let parse_of_string = List.map (fun f -> check_file f Test_parse_sexp.v)
let tests = [ ("parse_of_string", parse_of_string all_simple_files) ]
(* Run it *)
let () =
Junit_alcotest.run_and_report "Yaml" tests |> fun (r, e) ->
Junit.(to_file (make [ r ]) "alcotest2-junit.xml");
e ()
| (* Copyright (c) 2017-2021 Anil Madhavapeddy <anil@recoil.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. *) |
Src_file.mli | (*
A representation of the input document, used to recover code snippets
from locations.
*)
type t
type source = File of string | Stdin | String | Channel
(*
Read data from various sources.
Specifying max_len allows for reading at most the first max_len bytes
of data.
*)
val of_string : ?source:source -> string -> t
val of_channel : ?source:source -> ?max_len:int -> in_channel -> t
val of_stdin : ?source:source -> unit -> t
val of_file : ?source:source -> ?max_len:int -> string -> t
val to_lexbuf : t -> Lexing.lexbuf
val source : t -> source
val show_source : source -> string
val source_string : t -> string
val contents : t -> string
val length : t -> int
(*
Replace some of the contents, typically for blanking out comments
as part of a preprocessing phase.
*)
val replace_contents : t -> (string -> string) -> t
(*
Extract a specific region specified as
(start position, end position to be excluded).
*)
val region_of_pos_range : t -> Lexing.position -> Lexing.position -> string
(*
Extract a specific region specified by the positions of the first
and last tokens to be included in the region.
*)
val region_of_loc_range : t -> Loc.t -> Loc.t -> string
(*
Extract the lines containing a pair of positions.
This includes the beginning of the first line and the end of the last line
even if they're outside the requested range.
A trailing newline character (LF) is added unless 'force_trailing_newline'
is false. Regardless, a trailing newline is always included if there is
one in the source file.
*)
val lines_of_pos_range :
?force_trailing_newline:bool ->
?highlight:(string -> string) ->
?line_prefix:string ->
t ->
Lexing.position ->
Lexing.position ->
string
(*
Extract the lines containing a pair of locations.
A location itself is a range of positions, typically associated with
an input token.
See 'lines_of_pos_range' for details.
*)
val lines_of_loc_range :
?force_trailing_newline:bool ->
?highlight:(string -> string) ->
?line_prefix:string ->
t ->
Loc.t ->
Loc.t ->
string
(* Same as 'lines_of_pos_range' but split the text into a list of lines. *)
val list_lines_of_pos_range :
?highlight:(string -> string) ->
?line_prefix:string ->
t ->
Lexing.position ->
Lexing.position ->
string list
(* Same as 'lines_of_loc_range' but split the text into a list of lines. *)
val list_lines_of_loc_range :
?highlight:(string -> string) ->
?line_prefix:string ->
t ->
Loc.t ->
Loc.t ->
string list
(* not for public use, only exposed to allow unit tests *)
val insert_highlight : (string -> string) -> string -> int -> int -> string
| (*
A representation of the input document, used to recover code snippets
from locations.
*) |
pict_proto.mli |
type slide = Slideshow.slide
type t
val t : string -> t
val tt : string -> t
val p : ?align:[`left|`center|`right] -> ?fill:bool -> ?width:float -> string -> t
val frame : t -> t
val slide : ?title:string -> ?align:[`top|`mid|`bot] -> t list -> slide
| |
dune |
(rule
(alias runtest)
(deps ../src/bin/smtlib_cat.exe (:files (source_tree ./regressions)))
(action (run ./check_regs.exe %{files})))
(executable
(name check_regs))
| |
import.ml |
include Base
include Hardcaml
module Fir_filter = Hardcaml_test.Test_fir_filter
module Multiport_memory = Hardcaml_test.Test_multiport_memory
module Test_parameter = Hardcaml_test.Test_parameter
module In_channel = Stdio.In_channel
module Out_channel = Stdio.Out_channel
| |
michelson_v1_macros.mli | open Tezos_micheline
type 'l node = ('l, string) Micheline.node
type error += Unexpected_macro_annotation of string
type error += Sequence_expected of string
type error += Invalid_arity of string * int * int
val expand : 'l node -> 'l node tzresult
val expand_rec : 'l node -> 'l node * error list
val expand_caddadr : 'l node -> 'l node option tzresult
val expand_set_caddadr : 'l node -> 'l node option tzresult
val expand_map_caddadr : 'l node -> 'l node option tzresult
val expand_dxiiivp : 'l node -> 'l node option tzresult
val expand_pappaiir : 'l node -> 'l node option tzresult
val expand_duuuuup : 'l node -> 'l node option tzresult
val expand_compare : 'l node -> 'l node option tzresult
val expand_asserts : 'l node -> 'l node option tzresult
val expand_unpappaiir : 'l node -> 'l node option tzresult
val expand_if_some : 'l node -> 'l node option tzresult
val expand_if_right : 'l node -> 'l node option tzresult
val unexpand : 'l node -> 'l node
val unexpand_rec : 'l node -> 'l node
val unexpand_caddadr : 'l node -> 'l node option
val unexpand_set_caddadr : 'l node -> 'l node option
val unexpand_map_caddadr : 'l node -> 'l node option
val unexpand_dxiiivp : 'l node -> 'l node option
val unexpand_pappaiir : 'l node -> 'l node option
val unexpand_duuuuup : 'l node -> 'l node option
val unexpand_compare : 'l node -> 'l node option
val unexpand_asserts : 'l node -> 'l node option
val unexpand_unpappaiir : 'l node -> 'l node option
val unexpand_if_some : 'l node -> 'l node option
val unexpand_if_right : 'l node -> 'l node option
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
generate_ml_rlgl.ml |
let () =
Cstubs.write_ml Format.std_formatter ~prefix:Sys.argv.(1)
(module Raylib_rlgl.Description)
| |
emu_jisx0213_2000.h | /* These routines may be quite inefficient, but it's used only to emulate old
* standards. */
#ifndef EMULATE_JISX0213_2000_ENCODE_INVALID
# define EMULATE_JISX0213_2000_ENCODE_INVALID 1
#endif
#define EMULATE_JISX0213_2000_ENCODE_BMP(assi, c) \
if (config == (void *)2000 && ( \
(c) == 0x9B1C || (c) == 0x4FF1 || \
(c) == 0x525D || (c) == 0x541E || \
(c) == 0x5653 || (c) == 0x59F8 || \
(c) == 0x5C5B || (c) == 0x5E77 || \
(c) == 0x7626 || (c) == 0x7E6B)) { \
return EMULATE_JISX0213_2000_ENCODE_INVALID; \
} \
else if (config == (void *)2000 && (c) == 0x9B1D) { \
(assi) = 0x8000 | 0x7d3b; \
}
#define EMULATE_JISX0213_2000_ENCODE_EMP(assi, c) \
if (config == (void *)2000 && (c) == 0x20B9F) { \
return EMULATE_JISX0213_2000_ENCODE_INVALID; \
}
#ifndef EMULATE_JISX0213_2000_DECODE_INVALID
# define EMULATE_JISX0213_2000_DECODE_INVALID 2
#endif
#define EMULATE_JISX0213_2000_DECODE_PLANE1(assi, c1, c2) \
if (config == (void *)2000 && \
(((c1) == 0x2E && (c2) == 0x21) || \
((c1) == 0x2F && (c2) == 0x7E) || \
((c1) == 0x4F && (c2) == 0x54) || \
((c1) == 0x4F && (c2) == 0x7E) || \
((c1) == 0x74 && (c2) == 0x27) || \
((c1) == 0x7E && (c2) == 0x7A) || \
((c1) == 0x7E && (c2) == 0x7B) || \
((c1) == 0x7E && (c2) == 0x7C) || \
((c1) == 0x7E && (c2) == 0x7D) || \
((c1) == 0x7E && (c2) == 0x7E))) { \
return EMULATE_JISX0213_2000_DECODE_INVALID; \
}
#define EMULATE_JISX0213_2000_DECODE_PLANE2(writer, c1, c2) \
if (config == (void *)2000 && (c1) == 0x7D && (c2) == 0x3B) { \
OUTCHAR(0x9B1D); \
}
#define EMULATE_JISX0213_2000_DECODE_PLANE2_CHAR(assi, c1, c2) \
if (config == (void *)2000 && (c1) == 0x7D && (c2) == 0x3B) { \
(assi) = 0x9B1D; \
}
| /* These routines may be quite inefficient, but it's used only to emulate old
* standards. */ |
dune |
(library (name tuple_pool) (public_name core_kernel.tuple_pool)
(libraries core) (preprocess (pps ppx_jane))) | |
websocketaf_lwt.mli |
module type Server = Websocketaf_lwt_intf.Server
module type Client = Websocketaf_lwt_intf.Client
(* The function that results from [create_connection_handler] should be passed
to [Lwt_io.establish_server_with_client_socket]. For an example, see
[examples/lwt_echo_server.ml]. *)
module Server (Server_runtime : Gluten_lwt.Server) :
Server with type socket = Server_runtime.socket
and type addr := Server_runtime.addr
module Client (Client_runtime : Gluten_lwt.Client) :
Client with type socket = Client_runtime.socket
| |
array.mli |
type 'a t = 'a array
external length : 'a array -> int = "%array_length"
external get : 'a array -> int -> 'a = "%array_safe_get"
external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
external make : int -> 'a -> 'a array = "caml_make_vect"
external create : int -> 'a -> 'a array = "caml_make_vect"
external create_float : int -> float array = "caml_make_float_vect"
val make_float : int -> float array
val init : int -> (int -> 'a) -> 'a array
val make_matrix : int -> int -> 'a -> 'a array array
val create_matrix : int -> int -> 'a -> 'a array array
val append : 'a array -> 'a array -> 'a array
val concat : 'a array list -> 'a array
val sub : 'a array -> int -> int -> 'a array
val copy : 'a array -> 'a array
val fill : 'a array -> int -> int -> 'a -> unit
val blit : 'a array -> int -> 'a array -> int -> int -> unit
val to_list : 'a array -> 'a list
val of_list : 'a list -> 'a array
val iter : ('a -> unit) -> 'a array -> unit
val iteri : (int -> 'a -> unit) -> 'a array -> unit
val map : ('a -> 'b) -> 'a array -> 'b array
val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
val fold_left_map :
('a -> 'b -> ('a * 'c)) -> 'a -> 'b array -> ('a * 'c array)
val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
val for_all : ('a -> bool) -> 'a array -> bool
val exists : ('a -> bool) -> 'a array -> bool
val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
val mem : 'a -> 'a array -> bool
val memq : 'a -> 'a array -> bool
val find_opt : ('a -> bool) -> 'a array -> 'a option
val find_map : ('a -> 'b option) -> 'a array -> 'b option
val split : ('a * 'b) array -> ('a array * 'b array)
val combine : 'a array -> 'b array -> ('a * 'b) array
val sort : ('a -> 'a -> int) -> 'a array -> unit
val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
val to_seq : 'a array -> 'a Seq.t
val to_seqi : 'a array -> (int * 'a) Seq.t
val of_seq : 'a Seq.t -> 'a array
external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set"
module Floatarray :
sig
external create : int -> floatarray = "caml_floatarray_create"
external length : floatarray -> int = "%floatarray_length"
external get : floatarray -> int -> float = "%floatarray_safe_get"
external set : floatarray -> int -> float -> unit = "%floatarray_safe_set"
external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get"
external unsafe_set :
floatarray -> int -> float -> unit = "%floatarray_unsafe_set"
end
| |
test.mli | (* empty *)
| (* empty *)
|
michelson_v1_printer.ml | open Protocol
open Alpha_context
open Tezos_micheline
open Micheline
open Micheline_printer
let anon = {comment = None}
let print_expr ppf expr =
expr |> Michelson_v1_primitives.strings_of_prims
|> Micheline.inject_locations (fun _ -> anon)
|> print_expr ppf
let print_expr_unwrapped ppf expr =
expr |> Michelson_v1_primitives.strings_of_prims
|> Micheline.inject_locations (fun _ -> anon)
|> print_expr_unwrapped ppf
let print_var_annots ppf = List.iter (Format.fprintf ppf "%s ")
let print_annot_expr_unwrapped ppf (expr, annot) =
Format.fprintf ppf "%a%a" print_var_annots annot print_expr_unwrapped expr
let print_stack ppf = function
| [] -> Format.fprintf ppf "[]"
| more ->
Format.fprintf
ppf
"@[<hov 0>[ %a ]@]"
(Format.pp_print_list
~pp_sep:(fun ppf () -> Format.fprintf ppf "@ : ")
print_annot_expr_unwrapped)
more
let print_execution_trace ppf trace =
Format.pp_print_list
(fun ppf (loc, gas, stack) ->
Format.fprintf
ppf
"- @[<v 0>location: %d (remaining gas: %a)@,[ @[<v 0>%a ]@]@]"
loc
Gas.pp
gas
(Format.pp_print_list (fun ppf (e, annot) ->
Format.fprintf
ppf
"@[<v 0>%a \t%s@]"
print_expr
e
(match annot with None -> "" | Some a -> a)))
stack)
ppf
trace
let print_big_map_diff ppf lazy_storage_diff =
let diff =
Contract.Legacy_big_map_diff.of_lazy_storage_diff lazy_storage_diff
in
let pp_map ppf id =
if Compare.Z.(id < Z.zero) then
Format.fprintf ppf "temp(%s)" (Z.to_string (Z.neg id))
else Format.fprintf ppf "map(%s)" (Z.to_string id)
in
Format.fprintf
ppf
"@[<v 0>%a@]"
(Format.pp_print_list ~pp_sep:Format.pp_print_space (fun ppf -> function
| Contract.Legacy_big_map_diff.Clear id ->
Format.fprintf ppf "Clear %a" pp_map id
| Contract.Legacy_big_map_diff.Alloc {big_map; key_type; value_type} ->
Format.fprintf
ppf
"New %a of type (big_map %a %a)"
pp_map
big_map
print_expr
key_type
print_expr
value_type
| Contract.Legacy_big_map_diff.Copy {src; dst} ->
Format.fprintf ppf "Copy %a to %a" pp_map src pp_map dst
| Contract.Legacy_big_map_diff.Update {big_map; diff_key; diff_value; _}
->
Format.fprintf
ppf
"%s %a[%a]%a"
(match diff_value with None -> "Unset" | Some _ -> "Set")
pp_map
big_map
print_expr
diff_key
(fun ppf -> function
| None -> ()
| Some x -> Format.fprintf ppf " to %a" print_expr x)
diff_value))
(diff :> Contract.Legacy_big_map_diff.item list)
let inject_types type_map parsed =
let rec inject_expr = function
| Seq (loc, items) ->
Seq (inject_loc `before loc, List.map inject_expr items)
| Prim (loc, name, items, annot) ->
Prim (inject_loc `after loc, name, List.map inject_expr items, annot)
| Int (loc, value) -> Int (inject_loc `after loc, value)
| String (loc, value) -> String (inject_loc `after loc, value)
| Bytes (loc, value) -> Bytes (inject_loc `after loc, value)
and inject_loc which loc =
let comment =
let ( >?? ) = Option.bind in
List.assoc ~equal:Int.equal loc parsed.Michelson_v1_parser.expansion_table
>?? fun (_, locs) ->
let locs = List.sort compare locs in
List.hd locs >?? fun head_loc ->
List.assoc ~equal:Int.equal head_loc type_map >?? fun (bef, aft) ->
let stack = match which with `before -> bef | `after -> aft in
Some (Format.asprintf "%a" print_stack stack)
in
{comment}
in
inject_expr (root parsed.unexpanded)
let unparse ?type_map parse expanded =
let source =
match type_map with
| Some type_map ->
let (unexpanded, unexpansion_table) =
expanded |> Michelson_v1_primitives.strings_of_prims |> root
|> Michelson_v1_macros.unexpand_rec |> Micheline.extract_locations
in
let rec inject_expr = function
| Seq (loc, items) ->
Seq (inject_loc `before loc, List.map inject_expr items)
| Prim (loc, name, items, annot) ->
Prim
(inject_loc `after loc, name, List.map inject_expr items, annot)
| Int (loc, value) -> Int (inject_loc `after loc, value)
| String (loc, value) -> String (inject_loc `after loc, value)
| Bytes (loc, value) -> Bytes (inject_loc `after loc, value)
and inject_loc which loc =
let comment =
let ( >?? ) = Option.bind in
List.assoc ~equal:Int.equal loc unexpansion_table >?? fun loc ->
List.assoc ~equal:Int.equal loc type_map >?? fun (bef, aft) ->
let stack = match which with `before -> bef | `after -> aft in
Some (Format.asprintf "%a" print_stack stack)
in
{comment}
in
unexpanded |> root |> inject_expr
|> Format.asprintf "%a" Micheline_printer.print_expr
| None ->
expanded |> Michelson_v1_primitives.strings_of_prims |> root
|> Michelson_v1_macros.unexpand_rec |> Micheline.strip_locations
|> Micheline_printer.printable (fun n -> n)
|> Format.asprintf "%a" Micheline_printer.print_expr
in
match parse source with
| (res, []) -> res
| (_, _ :: _) -> Stdlib.failwith "Michelson_v1_printer.unparse"
let unparse_toplevel ?type_map =
unparse ?type_map Michelson_v1_parser.parse_toplevel
let unparse_expression = unparse Michelson_v1_parser.parse_expression
let unparse_invalid expanded =
let source =
expanded |> root |> Michelson_v1_macros.unexpand_rec
|> Micheline.strip_locations
|> Micheline_printer.printable (fun n -> n)
|> Format.asprintf "%a" Micheline_printer.print_expr_unwrapped
in
fst (Michelson_v1_parser.parse_toplevel source)
let ocaml_constructor_of_prim prim =
(* Assuming all the prim constructor prefixes match the
[[Michelson_v1_primitives.namespace]]. *)
let prefix =
Michelson_v1_primitives.(namespace prim |> string_of_namespace)
in
Format.asprintf "%s_%s" prefix @@ Michelson_v1_primitives.string_of_prim prim
let micheline_string_of_expression ~zero_loc expression =
let string_of_list : string list -> string =
fun xs -> String.concat "; " xs |> Format.asprintf "[%s]"
in
let show_loc loc = if zero_loc then 0 else loc in
let rec string_of_node = function
| Int (loc, i) ->
let z =
match Z.to_int i with
| 0 -> "Z.zero"
| 1 -> "Z.one"
| i -> Format.asprintf "Z.of_int %d" i
in
Format.asprintf "Int (%d, %s)" (show_loc loc) z
| String (loc, s) -> Format.asprintf "String (%d, \"%s\")" (show_loc loc) s
| Bytes (loc, b) ->
Format.asprintf
"Bytes (%d, Bytes.of_string \"%s\")"
(show_loc loc)
Bytes.(escaped b |> to_string)
| Prim (loc, prim, nodes, annot) ->
Format.asprintf
"Prim (%d, %s, %s, %s)"
(show_loc loc)
(ocaml_constructor_of_prim prim)
(string_of_list @@ List.map string_of_node nodes)
(string_of_list @@ List.map (Format.asprintf "\"%s\"") annot)
| Seq (loc, nodes) ->
Format.asprintf
"Seq (%d, %s)"
(show_loc loc)
(string_of_list @@ List.map string_of_node nodes)
in
string_of_node (root expression)
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
script_interpreter.mli | open Alpha_context
type execution_trace =
(Script.location * Gas.t * (Script.expr * string option) list) list
type error += Reject of Script.location * Script.expr * execution_trace option
type error += Overflow of Script.location * execution_trace option
type error += Runtime_contract_error : Contract.t * Script.expr -> error
type error += Bad_contract_parameter of Contract.t (* `Permanent *)
type error += Cannot_serialize_log
type error += Cannot_serialize_failure
type error += Cannot_serialize_storage
type execution_result =
{ ctxt : context ;
storage : Script.expr ;
big_map_diff : Contract.big_map_diff option ;
operations : packed_internal_operation list }
val execute:
Alpha_context.t ->
Script_ir_translator.unparsing_mode ->
source: Contract.t ->
payer: Contract.t ->
self: (Contract.t * Script.t) ->
parameter: Script.expr ->
amount: Tez.t ->
execution_result tzresult Lwt.t
val trace:
Alpha_context.t ->
Script_ir_translator.unparsing_mode ->
source: Contract.t ->
payer: Contract.t ->
self: (Contract.t * Script.t) ->
parameter: Script.expr ->
amount: Tez.t ->
(execution_result * execution_trace) tzresult Lwt.t
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
namespace.ml | let prefix = "zenon_";;
let anon_prefix = prefix ^ "A";;
let builtin_prefix = prefix ^ "B";;
let dummy_prefix = prefix ^ "D";;
let hyp_prefix = prefix ^ "H";;
let lemma_prefix = prefix ^ "L";;
let tau_prefix = prefix ^ "T";;
let var_prefix = prefix ^ "V";;
let meta_prefix = prefix ^ "X";;
let goal_name = prefix ^ "G";;
let any_name = prefix ^ "E";;
let univ_name = prefix ^ "U";;
let thm_default_name = prefix ^ "thm";;
let tuple_name = builtin_prefix ^ "tuple";;
| (* Copyright 2006 INRIA *)
|
voting_period_repr.mli | type t
type voting_period = t
val encoding: voting_period Data_encoding.t
val rpc_arg: voting_period RPC_arg.arg
val pp: Format.formatter -> voting_period -> unit
include Compare.S with type t := voting_period
val to_int32: voting_period -> int32
val of_int32_exn: int32 -> voting_period
val root: voting_period
val succ: voting_period -> voting_period
type kind =
| Proposal
| Testing_vote
| Testing
| Promotion_vote
val kind_encoding: kind Data_encoding.t
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
bar.ml | (* directly usable but will cause linking error *)
let run = Foo.run
| (* directly usable but will cause linking error *)
let run = Foo.run |
dune |
(library
(public_name psq)
(synopsis "Functional Priority Search Queues")
(libraries seq)
(wrapped false))
| |
position.mli |
type t =
{ row : int
; col : int
}
[@@deriving fields, sexp_of]
module One_indexed_row : sig
type zero_indexed_row := t
type t =
{ row : int
; col : int
}
[@@deriving fields, sexp_of]
val to_zero : t -> zero_indexed_row
val of_zero : zero_indexed_row -> t
end
| |
unix_readv_writev_utils.c | /* This file is part of Lwt, released under the MIT license. See LICENSE.md for
details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. */
#include "lwt_config.h"
#if !defined(LWT_ON_WINDOWS)
#include <caml/bigarray.h>
#include <caml/memory.h>
#include <caml/mlvalues.h>
#include <caml/unixsupport.h>
#include <string.h>
#include "lwt_unix.h"
#include "unix_readv_writev_utils.h"
void flatten_io_vectors(struct iovec *iovecs, value io_vectors,
size_t count, char **buffer_copies,
struct readv_copy_to *read_buffers)
{
CAMLparam1(io_vectors);
CAMLlocal3(node, io_vector, buffer);
size_t index;
size_t copy_index = 0;
for (node = io_vectors, index = 0; index < count;
node = Field(node, 1), ++index) {
io_vector = Field(node, 0);
intnat offset = Long_val(Field(io_vector, 1));
intnat length = Long_val(Field(io_vector, 2));
iovecs[index].iov_len = length;
buffer = Field(Field(io_vector, 0), 0);
if (Tag_val(Field(io_vector, 0)) == IO_vectors_bytes) {
if (buffer_copies != NULL) {
buffer_copies[copy_index] = lwt_unix_malloc(length);
memcpy(buffer_copies[copy_index],
&Byte(String_val(buffer), offset), length);
iovecs[index].iov_base = buffer_copies[copy_index];
++copy_index;
} else if (read_buffers != NULL) {
read_buffers[copy_index].temporary_buffer =
lwt_unix_malloc(length);
read_buffers[copy_index].length = length;
read_buffers[copy_index].offset = offset;
read_buffers[copy_index].caml_buffer = buffer;
caml_register_generational_global_root(
&read_buffers[copy_index].caml_buffer);
iovecs[index].iov_base =
read_buffers[copy_index].temporary_buffer;
++copy_index;
} else
iovecs[index].iov_base = &Byte(String_val(buffer), offset);
} else
iovecs[index].iov_base =
&((char *)Caml_ba_data_val(buffer))[offset];
}
if (buffer_copies != NULL) buffer_copies[copy_index] = NULL;
if (read_buffers != NULL) read_buffers[copy_index].temporary_buffer = NULL;
CAMLreturn0;
}
#endif
| /* This file is part of Lwt, released under the MIT license. See LICENSE.md for
details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. */ |
main_sc_rollup_client_alpha.ml | let executable_name = Filename.basename Sys.executable_name
let argv () = Array.to_list Sys.argv |> List.tl |> Stdlib.Option.get
let main () =
Configuration.parse (argv ()) >>=? fun (configuration, argv) ->
let cctxt = Configuration.make_unix_client_context configuration in
Clic.dispatch (Commands.all ()) cctxt argv
let handle_error = function
| Ok () -> Stdlib.exit 0
| Error [Clic.Version] ->
let version = Tezos_version.Bin_version.version_string in
Format.printf "%s\n" version ;
Stdlib.exit 0
| Error [Clic.Help command] ->
Clic.usage
Format.std_formatter
~executable_name
~global_options:(Configuration.global_options ())
(match command with None -> [] | Some c -> [c]) ;
Stdlib.exit 0
| Error errs ->
Clic.pp_cli_errors
Format.err_formatter
~executable_name
~global_options:(Configuration.global_options ())
~default:Error_monad.pp
errs ;
Stdlib.exit 1
let () = Lwt_main.run (Lwt.catch main fail_with_exn) |> handle_error
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
logs_syslog.ml |
let slevel = function
| Logs.App -> Syslog_message.Informational
| Logs.Error -> Syslog_message.Error
| Logs.Warning -> Syslog_message.Warning
| Logs.Info -> Syslog_message.Informational
| Logs.Debug -> Syslog_message.Debug
let ppf, flush =
let b = Buffer.create 255 in
let ppf = Format.formatter_of_buffer b in
let flush () =
Format.pp_print_flush ppf () ;
let s = Buffer.contents b in Buffer.clear b ; s
in
ppf, flush
let facility =
let ppf ppf v =
Format.pp_print_string ppf (Syslog_message.string_of_facility v)
in
Logs.Tag.def ~doc:"Syslog facility" "syslog-facility" ppf
let message ?facility:(syslog_facility = Syslog_message.System_Daemons)
~host:hostname ~source ~tags ?header level timestamp message =
let tags =
let tags = Logs.Tag.rem facility tags in
if Logs.Tag.is_empty tags then
""
else
(Logs.Tag.pp_set ppf tags ;
" " ^ flush ())
in
let hdr = match header with None -> "" | Some x -> " " ^ x in
let content = Printf.sprintf "%s%s %s" tags hdr message
and severity = slevel level
and tag = Astring.String.take ~max:32 source
in
{ Syslog_message.facility = syslog_facility ; severity ; timestamp ;
hostname ; tag ; content }
type framing = [
| `LineFeed
| `Null
| `Custom of string
| `Count
]
let frame_message msg = function
| `LineFeed -> msg ^ "\n"
| `Null -> msg ^ "\000"
| `Custom s -> msg ^ s
| `Count -> Printf.sprintf "%d %s" (String.length msg) msg
| |
link.c | /* SPDX-License-Identifier: MIT */
/*
* Description: run various linked sqe tests
*
*/
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include "liburing.h"
#include "helpers.h"
static int no_hardlink;
/*
* Timer with single nop
*/
static int test_single_hardlink(struct io_uring *ring)
{
struct __kernel_timespec ts;
struct io_uring_cqe *cqe;
struct io_uring_sqe *sqe;
int ret, i;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
fprintf(stderr, "get sqe failed\n");
goto err;
}
ts.tv_sec = 0;
ts.tv_nsec = 10000000ULL;
io_uring_prep_timeout(sqe, &ts, 0, 0);
sqe->flags |= IOSQE_IO_LINK | IOSQE_IO_HARDLINK;
sqe->user_data = 1;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
fprintf(stderr, "get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe->user_data = 2;
ret = io_uring_submit(ring);
if (ret <= 0) {
fprintf(stderr, "sqe submit failed: %d\n", ret);
goto err;
}
for (i = 0; i < 2; i++) {
ret = io_uring_wait_cqe(ring, &cqe);
if (ret < 0) {
fprintf(stderr, "wait completion %d\n", ret);
goto err;
}
if (!cqe) {
fprintf(stderr, "failed to get cqe\n");
goto err;
}
if (no_hardlink)
goto next;
if (cqe->user_data == 1 && cqe->res == -EINVAL) {
fprintf(stdout, "Hard links not supported, skipping\n");
no_hardlink = 1;
goto next;
}
if (cqe->user_data == 1 && cqe->res != -ETIME) {
fprintf(stderr, "timeout failed with %d\n", cqe->res);
goto err;
}
if (cqe->user_data == 2 && cqe->res) {
fprintf(stderr, "nop failed with %d\n", cqe->res);
goto err;
}
next:
io_uring_cqe_seen(ring, cqe);
}
return 0;
err:
return 1;
}
/*
* Timer -> timer -> nop
*/
static int test_double_hardlink(struct io_uring *ring)
{
struct __kernel_timespec ts1, ts2;
struct io_uring_cqe *cqe;
struct io_uring_sqe *sqe;
int ret, i;
if (no_hardlink)
return 0;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
fprintf(stderr, "get sqe failed\n");
goto err;
}
ts1.tv_sec = 0;
ts1.tv_nsec = 10000000ULL;
io_uring_prep_timeout(sqe, &ts1, 0, 0);
sqe->flags |= IOSQE_IO_LINK | IOSQE_IO_HARDLINK;
sqe->user_data = 1;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
fprintf(stderr, "get sqe failed\n");
goto err;
}
ts2.tv_sec = 0;
ts2.tv_nsec = 15000000ULL;
io_uring_prep_timeout(sqe, &ts2, 0, 0);
sqe->flags |= IOSQE_IO_LINK | IOSQE_IO_HARDLINK;
sqe->user_data = 2;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
fprintf(stderr, "get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe->user_data = 3;
ret = io_uring_submit(ring);
if (ret <= 0) {
fprintf(stderr, "sqe submit failed: %d\n", ret);
goto err;
}
for (i = 0; i < 3; i++) {
ret = io_uring_wait_cqe(ring, &cqe);
if (ret < 0) {
fprintf(stderr, "wait completion %d\n", ret);
goto err;
}
if (!cqe) {
fprintf(stderr, "failed to get cqe\n");
goto err;
}
if (cqe->user_data == 1 && cqe->res != -ETIME) {
fprintf(stderr, "timeout failed with %d\n", cqe->res);
goto err;
}
if (cqe->user_data == 2 && cqe->res != -ETIME) {
fprintf(stderr, "timeout failed with %d\n", cqe->res);
goto err;
}
if (cqe->user_data == 3 && cqe->res) {
fprintf(stderr, "nop failed with %d\n", cqe->res);
goto err;
}
io_uring_cqe_seen(ring, cqe);
}
return 0;
err:
return 1;
}
/*
* Test failing head of chain, and dependent getting -ECANCELED
*/
static int test_single_link_fail(struct io_uring *ring)
{
struct io_uring_cqe *cqe;
struct io_uring_sqe *sqe;
int ret, i;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_remove_buffers(sqe, 10, 1);
sqe->flags |= IOSQE_IO_LINK;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
ret = io_uring_submit(ring);
if (ret <= 0) {
printf("sqe submit failed: %d\n", ret);
goto err;
}
for (i = 0; i < 2; i++) {
ret = io_uring_peek_cqe(ring, &cqe);
if (ret < 0) {
printf("wait completion %d\n", ret);
goto err;
}
if (!cqe) {
printf("failed to get cqe\n");
goto err;
}
if (i == 0 && cqe->res != -ENOENT) {
printf("sqe0 failed with %d, wanted -ENOENT\n", cqe->res);
goto err;
}
if (i == 1 && cqe->res != -ECANCELED) {
printf("sqe1 failed with %d, wanted -ECANCELED\n", cqe->res);
goto err;
}
io_uring_cqe_seen(ring, cqe);
}
return 0;
err:
return 1;
}
/*
* Test two independent chains
*/
static int test_double_chain(struct io_uring *ring)
{
struct io_uring_cqe *cqe;
struct io_uring_sqe *sqe;
int ret, i;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe->flags |= IOSQE_IO_LINK;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe->flags |= IOSQE_IO_LINK;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
ret = io_uring_submit(ring);
if (ret <= 0) {
printf("sqe submit failed: %d\n", ret);
goto err;
}
for (i = 0; i < 4; i++) {
ret = io_uring_wait_cqe(ring, &cqe);
if (ret < 0) {
printf("wait completion %d\n", ret);
goto err;
}
io_uring_cqe_seen(ring, cqe);
}
return 0;
err:
return 1;
}
/*
* Test multiple dependents
*/
static int test_double_link(struct io_uring *ring)
{
struct io_uring_cqe *cqe;
struct io_uring_sqe *sqe;
int ret, i;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe->flags |= IOSQE_IO_LINK;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe->flags |= IOSQE_IO_LINK;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
ret = io_uring_submit(ring);
if (ret <= 0) {
printf("sqe submit failed: %d\n", ret);
goto err;
}
for (i = 0; i < 3; i++) {
ret = io_uring_wait_cqe(ring, &cqe);
if (ret < 0) {
printf("wait completion %d\n", ret);
goto err;
}
io_uring_cqe_seen(ring, cqe);
}
return 0;
err:
return 1;
}
/*
* Test single dependency
*/
static int test_single_link(struct io_uring *ring)
{
struct io_uring_cqe *cqe;
struct io_uring_sqe *sqe;
int ret, i;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
sqe->flags |= IOSQE_IO_LINK;
sqe = io_uring_get_sqe(ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
ret = io_uring_submit(ring);
if (ret <= 0) {
printf("sqe submit failed: %d\n", ret);
goto err;
}
for (i = 0; i < 2; i++) {
ret = io_uring_wait_cqe(ring, &cqe);
if (ret < 0) {
printf("wait completion %d\n", ret);
goto err;
}
io_uring_cqe_seen(ring, cqe);
}
return 0;
err:
return 1;
}
static int test_early_fail_and_wait(void)
{
struct io_uring ring;
struct io_uring_sqe *sqe;
int ret, invalid_fd = 42;
struct iovec iov = { .iov_base = NULL, .iov_len = 0 };
/* create a new ring as it leaves it dirty */
ret = io_uring_queue_init(8, &ring, 0);
if (ret) {
printf("ring setup failed\n");
return 1;
}
sqe = io_uring_get_sqe(&ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_readv(sqe, invalid_fd, &iov, 1, 0);
sqe->flags |= IOSQE_IO_LINK;
sqe = io_uring_get_sqe(&ring);
if (!sqe) {
printf("get sqe failed\n");
goto err;
}
io_uring_prep_nop(sqe);
ret = io_uring_submit_and_wait(&ring, 2);
if (ret <= 0 && ret != -EAGAIN) {
printf("sqe submit failed: %d\n", ret);
goto err;
}
io_uring_queue_exit(&ring);
return 0;
err:
io_uring_queue_exit(&ring);
return 1;
}
int main(int argc, char *argv[])
{
struct io_uring ring, poll_ring;
int ret;
if (argc > 1)
return T_EXIT_SKIP;
ret = io_uring_queue_init(8, &ring, 0);
if (ret) {
printf("ring setup failed\n");
return T_EXIT_FAIL;
}
ret = io_uring_queue_init(8, &poll_ring, IORING_SETUP_IOPOLL);
if (ret) {
printf("poll_ring setup failed\n");
return T_EXIT_FAIL;
}
ret = test_single_link(&ring);
if (ret) {
printf("test_single_link failed\n");
return ret;
}
ret = test_double_link(&ring);
if (ret) {
printf("test_double_link failed\n");
return ret;
}
ret = test_double_chain(&ring);
if (ret) {
printf("test_double_chain failed\n");
return ret;
}
ret = test_single_link_fail(&poll_ring);
if (ret) {
printf("test_single_link_fail failed\n");
return ret;
}
ret = test_single_hardlink(&ring);
if (ret) {
fprintf(stderr, "test_single_hardlink\n");
return ret;
}
ret = test_double_hardlink(&ring);
if (ret) {
fprintf(stderr, "test_double_hardlink\n");
return ret;
}
ret = test_early_fail_and_wait();
if (ret) {
fprintf(stderr, "test_early_fail_and_wait\n");
return ret;
}
return T_EXIT_PASS;
}
| /* SPDX-License-Identifier: MIT */
/* |
ppxutil.mli | (**pp -syntax camlp5r *)
value uv : Ploc.vala α → α;
value with_buffer_formatter : (Format.formatter → α → β) → α → string;
value duplicated : list string → bool;
value filter_split : (α → bool) → list α → (list α * list α);
value count : (α → bool) → list α → int;
value attr_id : MLast.attribute → string;
value module_expr_of_longident : MLast.longid → MLast.module_expr;
value longid_of_expr : MLast.expr -> MLast.longid ;
value expr_of_longid : MLast.longid -> MLast.expr ;
value convert_down_list_expr : (MLast.expr -> 'a) -> MLast.expr -> list 'a ;
value convert_up_list_expr : Ploc.t -> list MLast.expr -> MLast.expr ;
module Env : sig
type t 'a = list (string * 'a) ;
value add : Ploc.t -> t 'a -> string -> 'a -> t 'a ;
value append : Ploc.t -> t 'a -> t 'a -> t 'a ;
end
;
module Expr :
sig
value print : MLast.expr → string;
value to_string_list : MLast.expr → list string;
value prepend_longident : MLast.longid → MLast.expr → MLast.expr;
value abstract_over : list MLast.patt → MLast.expr → MLast.expr;
value applist : MLast.expr → list MLast.expr → MLast.expr;
value unapplist : MLast.expr → (MLast.expr * list MLast.expr);
value tuple : MLast.loc -> list MLast.expr -> MLast.expr ;
end
;
module Patt :
sig
value applist : MLast.patt → list MLast.patt → MLast.patt;
value unapplist : MLast.patt → (MLast.patt * list MLast.patt);
value wrap_attrs : MLast.patt → list MLast.attribute → MLast.patt;
value unwrap_attrs : MLast.patt → (MLast.patt * list MLast.attribute);
value tuple : MLast.loc -> list MLast.patt -> MLast.patt ;
end
;
module Ctyp :
sig
value print : MLast.ctyp → string;
value arrows_list : MLast.loc → list MLast.ctyp → MLast.ctyp → MLast.ctyp;
value wrap_attrs : MLast.ctyp → list MLast.attribute → MLast.ctyp;
value unwrap_attrs : MLast.ctyp → (MLast.ctyp * list MLast.attribute);
value applist : MLast.ctyp → list MLast.ctyp → MLast.ctyp;
value unapplist : MLast.ctyp → (MLast.ctyp * list MLast.ctyp);
value tuple : MLast.loc -> list MLast.ctyp -> MLast.ctyp ;
type rho = Env.t MLast.ctyp ;
value subst : rho -> MLast.ctyp -> MLast.ctyp;
end
;
module Longid : sig value to_string_list : MLast.longid → list string; end;
value is_poly_variant : MLast.ctyp → bool;
value is_generative_type : MLast.ctyp → bool;
value ocaml_location :
(string * int * int * int * int * int * int) → Location.t;
value mkloc : Ploc.t → Location.t;
value start_position_of_loc : Ploc.t → Lexing.position;
value end_position_of_loc : Ploc.t → Lexing.position;
value quote_position : MLast.loc → Lexing.position → MLast.expr;
value loc_of_type_decl : MLast.type_decl → MLast.loc;
value option_map : ('a -> 'b) -> option 'a -> option 'b;
value vala_map : ('a -> 'b) -> Ploc.vala 'a -> Ploc.vala 'b;
module AList : sig
value assoc : ?cmp:('a -> 'a -> bool) -> 'a -> list ('a * 'b) -> 'b ;
value mem : ?cmp:('a -> 'a -> bool) -> 'a -> list ('a * 'b) -> bool ;
value remove : ?cmp:('a -> 'a -> bool) -> 'a -> list ('a * 'b) -> list ('a * 'b) ;
end
;
value failwithf : format4 'a Format.formatter unit 'b -> 'a ;
value raise_failwith : Ploc.t -> string -> 'a ;
value raise_failwithf : Ploc.t -> format4 'a Format.formatter unit 'b -> 'a ;
| (**pp -syntax camlp5r *)
value uv : Ploc.vala α → α; |
pr6938.ml | (* TEST
include testing
*)
(* these are not valid under -strict-formats, but we test them here
for backward-compatibility *)
Printf.printf "%047.27d\n" 1036201459;;
Printf.printf "%047.27ld\n" 1036201459l;;
Printf.printf "%047.27Ld\n" 1036201459L;;
Printf.printf "%047.27nd\n" 1036201459n;;
print_newline ();;
Printf.printf "%047.27i\n" 1036201459;;
Printf.printf "%047.27li\n" 1036201459l;;
Printf.printf "%047.27Li\n" 1036201459L;;
Printf.printf "%047.27ni\n" 1036201459n;;
print_newline ();;
Printf.printf "%047.27u\n" 1036201459;;
Printf.printf "%047.27lu\n" 1036201459l;;
Printf.printf "%047.27Lu\n" 1036201459L;;
Printf.printf "%047.27nu\n" 1036201459n;;
print_newline ();;
Printf.printf "%047.27x\n" 1036201459;;
Printf.printf "%047.27lx\n" 1036201459l;;
Printf.printf "%047.27Lx\n" 1036201459L;;
Printf.printf "%047.27nx\n" 1036201459n;;
print_newline ();;
Printf.printf "%047.27X\n" 1036201459;;
Printf.printf "%047.27lX\n" 1036201459l;;
Printf.printf "%047.27LX\n" 1036201459L;;
Printf.printf "%047.27nX\n" 1036201459n;;
print_newline ();;
Printf.printf "%047.27o\n" 1036201459;;
Printf.printf "%047.27lo\n" 1036201459l;;
Printf.printf "%047.27Lo\n" 1036201459L;;
Printf.printf "%047.27no\n" 1036201459n;;
include Testing
| (* TEST
include testing
*) |
test.mli | (* empty *)
| (* empty *)
|
dune |
(library
(libraries exe)
(name foo))
| |
baking_nonces.ml | open Protocol
open Alpha_context
module Events = Baking_events.Nonces
type state = {
cctxt : Protocol_client_context.full;
chain : Chain_services.chain;
constants : Constants.t;
config : Baking_configuration.nonce_config;
nonces_location : [`Nonce] Baking_files.location;
mutable last_predecessor : Block_hash.t;
}
type t = state
type nonces = Nonce.t Block_hash.Map.t
let empty = Block_hash.Map.empty
let encoding =
let open Data_encoding in
def "seed_nonce"
@@ conv
(fun m ->
Block_hash.Map.fold (fun hash nonce acc -> (hash, nonce) :: acc) m [])
(fun l ->
List.fold_left
(fun map (hash, nonce) -> Block_hash.Map.add hash nonce map)
Block_hash.Map.empty
l)
@@ list (obj2 (req "block" Block_hash.encoding) (req "nonce" Nonce.encoding))
let may_migrate (wallet : Protocol_client_context.full) location =
let base_dir = wallet#get_base_dir in
let current_file =
Filename.Infix.((base_dir // Baking_files.filename location) ^ "s")
in
Lwt_unix.file_exists current_file >>= function
| true ->
(* Migration already occured *)
Lwt.return_unit
| false -> (
let legacy_file = Filename.Infix.(base_dir // "nonces") in
Lwt_unix.file_exists legacy_file >>= function
| false ->
(* Do nothing *)
Lwt.return_unit
| true -> Lwt_utils_unix.copy_file ~src:legacy_file ~dst:current_file)
let load (wallet : #Client_context.wallet) location =
wallet#load (Baking_files.filename location) ~default:empty encoding
let save (wallet : #Client_context.wallet) location nonces =
wallet#write (Baking_files.filename location) nonces encoding
let mem nonces hash = Block_hash.Map.mem hash nonces
let find_opt nonces hash = Block_hash.Map.find hash nonces
let add nonces hash nonce = Block_hash.Map.add hash nonce nonces
let remove nonces hash = Block_hash.Map.remove hash nonces
let remove_all nonces nonces_to_remove =
Block_hash.Map.fold
(fun hash _ acc -> remove acc hash)
nonces_to_remove
nonces
let get_block_level_opt cctxt ~chain ~block =
Shell_services.Blocks.Header.shell_header cctxt ~chain ~block () >>= function
| Ok {level; _} -> Lwt.return_some level
| Error errs ->
Events.(
emit
cant_retrieve_block_header_for_nonce
(Block_services.to_string block, errs))
>>= fun () -> Lwt.return_none
let get_outdated_nonces {cctxt; constants; chain; _} nonces =
let {Constants.parametric = {blocks_per_cycle; preserved_cycles; _}; _} =
constants
in
get_block_level_opt cctxt ~chain ~block:(`Head 0) >>= function
| None ->
Events.(emit cannot_fetch_chain_head_level ()) >>= fun () ->
return (empty, empty)
| Some current_level ->
let current_cycle = Int32.(div current_level blocks_per_cycle) in
let is_older_than_preserved_cycles block_level =
let block_cycle = Int32.(div block_level blocks_per_cycle) in
Int32.sub current_cycle block_cycle > Int32.of_int preserved_cycles
in
Block_hash.Map.fold
(fun hash nonce acc ->
acc >>=? fun (orphans, outdated) ->
get_block_level_opt cctxt ~chain ~block:(`Hash (hash, 0)) >>= function
| Some level ->
if is_older_than_preserved_cycles level then
return (orphans, add outdated hash nonce)
else acc
| None -> return (add orphans hash nonce, outdated))
nonces
(return (empty, empty))
let filter_outdated_nonces state nonces =
get_outdated_nonces state nonces >>=? fun (orphans, outdated_nonces) ->
when_
(Block_hash.Map.cardinal orphans >= 50)
(fun () ->
Events.(
emit too_many_nonces (Baking_files.filename state.nonces_location ^ "s"))
>>= fun () -> return_unit)
>>=? fun () -> return (remove_all nonces outdated_nonces)
let blocks_from_current_cycle {cctxt; chain; _} block ?(offset = 0l) () =
Shell_services.Blocks.hash cctxt ~chain ~block () >>=? fun hash ->
Shell_services.Blocks.Header.shell_header cctxt ~chain ~block ()
>>=? fun {level; _} ->
Plugin.RPC.levels_in_current_cycle cctxt ~offset (chain, block) >>= function
| Error (RPC_context.Not_found _ :: _) -> return_nil
| Error _ as err -> Lwt.return err
| Ok (first, last) ->
(* FIXME: crappy algorithm, change this *)
let length = Int32.to_int (Int32.sub level (Raw_level.to_int32 first)) in
Shell_services.Blocks.list cctxt ~chain ~heads:[hash] ~length ()
>>=? fun blocks ->
let head = Stdlib.List.hd blocks in
let blocks =
List.remove (length - Int32.to_int (Raw_level.diff last first)) head
in
if Int32.equal level (Raw_level.to_int32 last) then
return (hash :: blocks)
else return blocks
let get_unrevealed_nonces ({cctxt; chain; _} as state) nonces =
blocks_from_current_cycle state (`Head 0) ~offset:(-1l) () >>=? fun blocks ->
List.filter_map_es
(fun hash ->
match find_opt nonces hash with
| None -> return_none
| Some nonce -> (
get_block_level_opt cctxt ~chain ~block:(`Hash (hash, 0)) >>= function
| Some level -> (
Lwt.return (Environment.wrap_tzresult (Raw_level.of_int32 level))
>>=? fun level ->
Alpha_services.Nonce.get cctxt (chain, `Head 0) level
>>=? function
| Missing nonce_hash when Nonce.check_hash nonce nonce_hash ->
Events.(
emit found_nonce_to_reveal (hash, Raw_level.to_int32 level))
>>= fun () -> return_some (level, nonce)
| Missing _nonce_hash ->
Events.(emit incoherent_nonce (Raw_level.to_int32 level))
>>= fun () -> return_none
| Forgotten -> return_none
| Revealed _ -> return_none)
| None -> return_none))
blocks
(* Nonce creation *)
let generate_seed_nonce (nonce_config : Baking_configuration.nonce_config)
(delegate : Baking_state.delegate) level =
(match nonce_config with
| Deterministic ->
let data = Data_encoding.Binary.to_bytes_exn Raw_level.encoding level in
Client_keys.deterministic_nonce delegate.secret_key_uri data
>>=? fun nonce ->
return (Data_encoding.Binary.of_bytes_exn Nonce.encoding nonce)
| Random -> (
match Nonce.of_bytes (Rand.generate Constants.nonce_length) with
| Error _errs -> assert false
| Ok nonce -> return nonce))
>>=? fun nonce -> return (Nonce.hash nonce, nonce)
let register_nonce (cctxt : #Protocol_client_context.full) ~chain_id block_hash
nonce =
Events.(emit registering_nonce block_hash) >>= fun () ->
(* Register the nonce *)
let nonces_location = Baking_files.resolve_location ~chain_id `Nonce in
cctxt#with_lock @@ fun () ->
load cctxt nonces_location >>=? fun nonces ->
let nonces = add nonces block_hash nonce in
save cctxt nonces_location nonces >>=? fun () -> return_unit
let inject_seed_nonce_revelation (cctxt : #Protocol_client_context.full) ~chain
~block ~branch nonces =
match nonces with
| [] -> Events.(emit nothing_to_reveal branch) >>= fun () -> return_unit
| _ ->
List.iter_es
(fun (level, nonce) ->
Plugin.RPC.Forge.seed_nonce_revelation
cctxt
(chain, block)
~branch
~level
~nonce
()
>>=? fun bytes ->
let bytes = Signature.concat bytes Signature.zero in
Shell_services.Injection.operation ~async:true cctxt ~chain bytes
>>=? fun oph ->
Events.(
emit
revealing_nonce
(Raw_level.to_int32 level, Chain_services.to_string chain, oph))
>>= fun () -> return_unit)
nonces
(** [reveal_potential_nonces] reveal registered nonces *)
let reveal_potential_nonces
({cctxt; chain; nonces_location; last_predecessor; _} as state) new_proposal
=
let new_predecessor_hash = new_proposal.Baking_state.predecessor.hash in
if
Block_hash.(last_predecessor <> new_predecessor_hash)
&& Protocol_hash.(new_proposal.predecessor.protocol = Protocol.hash)
then (
(* only try revealing nonces when the proposal's predecessor is a new one *)
state.last_predecessor <- new_predecessor_hash ;
let block = `Head 0 in
let branch = new_predecessor_hash in
(* improve concurrency *)
cctxt#with_lock @@ fun () ->
load cctxt nonces_location >>= function
| Error err ->
Events.(emit cannot_read_nonces err) >>= fun () -> return_unit
| Ok nonces -> (
get_unrevealed_nonces state nonces >>= function
| Error err ->
Events.(emit cannot_retrieve_unrevealed_nonces err) >>= fun () ->
return_unit
| Ok [] -> return_unit
| Ok nonces_to_reveal -> (
inject_seed_nonce_revelation
cctxt
~chain
~block
~branch
nonces_to_reveal
>>= function
| Error err ->
Events.(emit cannot_inject_nonces err) >>= fun () -> return_unit
| Ok () ->
(* If some nonces are to be revealed it means:
- We entered a new cycle and we can clear old nonces ;
- A revelation was not included yet in the cycle beginning.
So, it is safe to only filter outdated_nonces there *)
filter_outdated_nonces state nonces >>=? fun live_nonces ->
save cctxt nonces_location live_nonces >>=? fun () ->
return_unit)))
else return_unit
(* We suppose that the block stream is cloned by the caller *)
let start_revelation_worker cctxt config chain_id constants block_stream =
let nonces_location = Baking_files.resolve_location ~chain_id `Nonce in
may_migrate cctxt nonces_location >>= fun () ->
let chain = `Hash chain_id in
let canceler = Lwt_canceler.create () in
let should_shutdown = ref false in
let state =
{
cctxt;
chain;
constants;
config;
nonces_location;
last_predecessor = Block_hash.zero;
}
in
let rec worker_loop () =
Lwt_canceler.on_cancel canceler (fun () ->
should_shutdown := true ;
Lwt.return_unit) ;
Lwt_stream.get block_stream >>= function
| None ->
(* The head stream closed meaning that the connection
with the node was interrupted: exit *)
return_unit
| Some new_proposal ->
if !should_shutdown then return_unit
else
reveal_potential_nonces state new_proposal >>=? fun () ->
worker_loop ()
in
Lwt.dont_wait
(fun () ->
Lwt.finalize
(fun () ->
Events.(emit revelation_worker_started ()) >>= fun () ->
worker_loop () >>= fun _ -> (* never ending loop *) Lwt.return_unit)
(fun () -> (* TODO *) Lwt.return_unit))
(fun _exn -> ()) ;
Lwt.return canceler
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2021 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
bytes.mli |
external length : bytes -> int = "%bytes_length"
external get : bytes -> int -> char = "%bytes_safe_get"
external set : bytes -> int -> char -> unit = "%bytes_safe_set"
external create : int -> bytes = "caml_create_bytes"
val make : int -> char -> bytes
val init : int -> (int -> char) -> bytes
val empty : bytes
val copy : bytes -> bytes
val of_string : string -> bytes
val to_string : bytes -> string
val sub : bytes -> int -> int -> bytes
val sub_string : bytes -> int -> int -> string
val extend : bytes -> int -> int -> bytes
val fill : bytes -> int -> int -> char -> unit
val blit : bytes -> int -> bytes -> int -> int -> unit
val blit_string : string -> int -> bytes -> int -> int -> unit
val concat : bytes -> bytes list -> bytes
val cat : bytes -> bytes -> bytes
val iter : (char -> unit) -> bytes -> unit
val iteri : (int -> char -> unit) -> bytes -> unit
val map : (char -> char) -> bytes -> bytes
val mapi : (int -> char -> char) -> bytes -> bytes
val fold_left : ('a -> char -> 'a) -> 'a -> bytes -> 'a
val fold_right : (char -> 'a -> 'a) -> bytes -> 'a -> 'a
val for_all : (char -> bool) -> bytes -> bool
val exists : (char -> bool) -> bytes -> bool
val trim : bytes -> bytes
val escaped : bytes -> bytes
val index : bytes -> char -> int
val index_opt : bytes -> char -> int option
val rindex : bytes -> char -> int
val rindex_opt : bytes -> char -> int option
val index_from : bytes -> int -> char -> int
val index_from_opt : bytes -> int -> char -> int option
val rindex_from : bytes -> int -> char -> int
val rindex_from_opt : bytes -> int -> char -> int option
val contains : bytes -> char -> bool
val contains_from : bytes -> int -> char -> bool
val rcontains_from : bytes -> int -> char -> bool
val uppercase : bytes -> bytes
val lowercase : bytes -> bytes
val capitalize : bytes -> bytes
val uncapitalize : bytes -> bytes
val uppercase_ascii : bytes -> bytes
val lowercase_ascii : bytes -> bytes
val capitalize_ascii : bytes -> bytes
val uncapitalize_ascii : bytes -> bytes
type t = bytes
val compare : t -> t -> int
val equal : t -> t -> bool
val starts_with : prefix:bytes -> bytes -> bool
val ends_with : suffix:bytes -> bytes -> bool
val unsafe_to_string : bytes -> string
val unsafe_of_string : string -> bytes
val split_on_char : char -> bytes -> bytes list
val to_seq : t -> char Seq.t
val to_seqi : t -> (int * char) Seq.t
val of_seq : char Seq.t -> t
val get_utf_8_uchar : t -> int -> Uchar.utf_decode
val set_utf_8_uchar : t -> int -> Uchar.t -> int
val is_valid_utf_8 : t -> bool
val get_utf_16be_uchar : t -> int -> Uchar.utf_decode
val set_utf_16be_uchar : t -> int -> Uchar.t -> int
val is_valid_utf_16be : t -> bool
val get_utf_16le_uchar : t -> int -> Uchar.utf_decode
val set_utf_16le_uchar : t -> int -> Uchar.t -> int
val is_valid_utf_16le : t -> bool
val get_uint8 : bytes -> int -> int
val get_int8 : bytes -> int -> int
val get_uint16_ne : bytes -> int -> int
val get_uint16_be : bytes -> int -> int
val get_uint16_le : bytes -> int -> int
val get_int16_ne : bytes -> int -> int
val get_int16_be : bytes -> int -> int
val get_int16_le : bytes -> int -> int
val get_int32_ne : bytes -> int -> int32
val get_int32_be : bytes -> int -> int32
val get_int32_le : bytes -> int -> int32
val get_int64_ne : bytes -> int -> int64
val get_int64_be : bytes -> int -> int64
val get_int64_le : bytes -> int -> int64
val set_uint8 : bytes -> int -> int -> unit
val set_int8 : bytes -> int -> int -> unit
val set_uint16_ne : bytes -> int -> int -> unit
val set_uint16_be : bytes -> int -> int -> unit
val set_uint16_le : bytes -> int -> int -> unit
val set_int16_ne : bytes -> int -> int -> unit
val set_int16_be : bytes -> int -> int -> unit
val set_int16_le : bytes -> int -> int -> unit
val set_int32_ne : bytes -> int -> int32 -> unit
val set_int32_be : bytes -> int -> int32 -> unit
val set_int32_le : bytes -> int -> int32 -> unit
val set_int64_ne : bytes -> int -> int64 -> unit
val set_int64_be : bytes -> int -> int64 -> unit
val set_int64_le : bytes -> int -> int64 -> unit
external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get"
external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set"
external unsafe_blit :
bytes -> int -> bytes -> int -> int -> unit = "caml_blit_bytes"[@@noalloc ]
external unsafe_blit_string :
string -> int -> bytes -> int -> int -> unit = "caml_blit_string"[@@noalloc
]
external unsafe_fill :
bytes -> int -> int -> char -> unit = "caml_fill_bytes"[@@noalloc ]
| |
dune |
(library
(name git_mirage_ssh)
(modules git_mirage_ssh)
(public_name git-mirage.ssh)
(libraries
mimic-happy-eyeballs
git.nss.git
mimic
lwt
fmt
result
tcpip
mirage-flow
mirage-time
mirage-clock
awa
awa-mirage))
(library
(name git_mirage_tcp)
(modules git_mirage_tcp)
(public_name git-mirage.tcp)
(libraries
mimic-happy-eyeballs
git.nss.git
mimic
lwt
fmt
result
tcpip
mirage-flow))
(library
(name git_mirage_http)
(modules git_mirage_http)
(public_name git-mirage.http)
(libraries
base64
mimic-happy-eyeballs
git-paf
git.nss.git
mimic
lwt
fmt
tls
uri
hex
x509
mirage-crypto
tls-mirage
ptime
cstruct
result
ca-certs-nss
domain-name
tcpip
mirage-flow
mirage-time
mirage-clock))
| |
outbox.ml | open Node_context
open Protocol.Alpha_context
module Make (PVM : Pvm.S) = struct
let get_state_of_lcc node_ctxt =
let open Lwt_result_syntax in
let* block_hash =
Node_context.hash_of_level
node_ctxt
(Raw_level.to_int32 node_ctxt.lcc.level)
in
let* ctxt = Node_context.checkout_context node_ctxt block_hash in
let*! state = PVM.State.find ctxt in
return state
let proof_of_output node_ctxt output =
let open Lwt_result_syntax in
let* state = get_state_of_lcc node_ctxt in
match state with
| None ->
(*
This case should never happen as origination creates an LCC which
must have been considered by the rollup node at startup time.
*)
failwith "Error producing outbox proof (no cemented state in the node)"
| Some state -> (
let*! proof = PVM.produce_output_proof node_ctxt.context state output in
match proof with
| Ok proof ->
let serialized_proof =
Data_encoding.Binary.to_string_exn PVM.output_proof_encoding proof
in
return @@ (node_ctxt.lcc.commitment, serialized_proof)
| Error err ->
failwith
"Error producing outbox proof (%a)"
Environment.Error_monad.pp
err)
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
t-compose_mod_horner.c |
#ifdef T
#include "templates.h"
#include <stdio.h>
#include <stdlib.h>
#include <gmp.h>
#include "flint.h"
#include "ulong_extras.h"
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("compose_mod_horner....");
fflush(stdout);
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
TEMPLATE(T, ctx_t) ctx;
TEMPLATE(T, poly_t) a, b, c, d, e;
TEMPLATE(T, ctx_randtest) (ctx, state);
TEMPLATE(T, poly_init) (a, ctx);
TEMPLATE(T, poly_init) (b, ctx);
TEMPLATE(T, poly_init) (c, ctx);
TEMPLATE(T, poly_init) (d, ctx);
TEMPLATE(T, poly_init) (e, ctx);
TEMPLATE(T, poly_randtest) (a, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest) (b, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest_not_zero) (c, state,
n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_compose_mod_horner) (d, a, b, c, ctx);
TEMPLATE(T, poly_compose) (e, a, b, ctx);
TEMPLATE(T, poly_rem) (e, e, c, ctx);
if (!TEMPLATE(T, poly_equal) (d, e, ctx))
{
flint_printf("FAIL (composition):\n");
flint_printf("a:\n");
TEMPLATE(T, poly_print) (a, ctx);
flint_printf("\n");
flint_printf("b:\n");
TEMPLATE(T, poly_print) (b, ctx);
flint_printf("\n");
flint_printf("c:\n");
TEMPLATE(T, poly_print) (c, ctx);
flint_printf("\n");
flint_printf("d:\n");
TEMPLATE(T, poly_print) (d, ctx);
flint_printf("\n");
flint_printf("e:\n");
TEMPLATE(T, poly_print) (e, ctx);
flint_printf("\n");
fflush(stdout);
flint_abort();
}
TEMPLATE(T, poly_clear) (a, ctx);
TEMPLATE(T, poly_clear) (b, ctx);
TEMPLATE(T, poly_clear) (c, ctx);
TEMPLATE(T, poly_clear) (d, ctx);
TEMPLATE(T, poly_clear) (e, ctx);
TEMPLATE(T, ctx_clear) (ctx);
}
/* Test aliasing of res and a */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
TEMPLATE(T, ctx_t) ctx;
TEMPLATE(T, poly_t) a, b, c, d;
TEMPLATE(T, ctx_randtest) (ctx, state);
TEMPLATE(T, poly_init) (a, ctx);
TEMPLATE(T, poly_init) (b, ctx);
TEMPLATE(T, poly_init) (c, ctx);
TEMPLATE(T, poly_init) (d, ctx);
TEMPLATE(T, poly_randtest) (a, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest) (b, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest_not_zero) (c, state,
n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_compose_mod_horner) (d, a, b, c, ctx);
TEMPLATE(T, poly_compose_mod_horner) (a, a, b, c, ctx);
if (!TEMPLATE(T, poly_equal) (d, a, ctx))
{
flint_printf("FAIL (aliasing a):\n");
flint_printf("a:\n");
TEMPLATE(T, poly_print) (a, ctx);
flint_printf("\n");
flint_printf("b:\n");
TEMPLATE(T, poly_print) (b, ctx);
flint_printf("\n");
flint_printf("c:\n");
TEMPLATE(T, poly_print) (c, ctx);
flint_printf("\n");
flint_printf("d:\n");
TEMPLATE(T, poly_print) (d, ctx);
flint_printf("\n");
fflush(stdout);
flint_abort();
}
TEMPLATE(T, poly_clear) (a, ctx);
TEMPLATE(T, poly_clear) (b, ctx);
TEMPLATE(T, poly_clear) (c, ctx);
TEMPLATE(T, poly_clear) (d, ctx);
TEMPLATE(T, ctx_clear) (ctx);
}
/* Test aliasing of res and b */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
TEMPLATE(T, ctx_t) ctx;
TEMPLATE(T, poly_t) a, b, c, d;
TEMPLATE(T, ctx_randtest) (ctx, state);
TEMPLATE(T, poly_init) (a, ctx);
TEMPLATE(T, poly_init) (b, ctx);
TEMPLATE(T, poly_init) (c, ctx);
TEMPLATE(T, poly_init) (d, ctx);
TEMPLATE(T, poly_randtest) (a, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest) (b, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest_not_zero) (c, state,
n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_compose_mod_horner) (d, a, b, c, ctx);
TEMPLATE(T, poly_compose_mod_horner) (b, a, b, c, ctx);
if (!TEMPLATE(T, poly_equal) (d, b, ctx))
{
flint_printf("FAIL (aliasing b)\n");
flint_printf("a:\n");
TEMPLATE(T, poly_print) (a, ctx);
flint_printf("\n");
flint_printf("b:\n");
TEMPLATE(T, poly_print) (b, ctx);
flint_printf("\n");
flint_printf("c:\n");
TEMPLATE(T, poly_print) (c, ctx);
flint_printf("\n");
flint_printf("d:\n");
TEMPLATE(T, poly_print) (d, ctx);
flint_printf("\n");
fflush(stdout);
flint_abort();
}
TEMPLATE(T, poly_clear) (a, ctx);
TEMPLATE(T, poly_clear) (b, ctx);
TEMPLATE(T, poly_clear) (c, ctx);
TEMPLATE(T, poly_clear) (d, ctx);
TEMPLATE(T, ctx_clear) (ctx);
}
/* Test aliasing of res and c */
for (i = 0; i < 20 * flint_test_multiplier(); i++)
{
TEMPLATE(T, ctx_t) ctx;
TEMPLATE(T, poly_t) a, b, c, d;
TEMPLATE(T, ctx_randtest) (ctx, state);
TEMPLATE(T, poly_init) (a, ctx);
TEMPLATE(T, poly_init) (b, ctx);
TEMPLATE(T, poly_init) (c, ctx);
TEMPLATE(T, poly_init) (d, ctx);
TEMPLATE(T, poly_randtest) (a, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest) (b, state, n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_randtest_not_zero) (c, state,
n_randint(state, 20) + 1, ctx);
TEMPLATE(T, poly_compose_mod_horner) (d, a, b, c, ctx);
TEMPLATE(T, poly_compose_mod_horner) (c, a, b, c, ctx);
if (!TEMPLATE(T, poly_equal) (d, c, ctx))
{
flint_printf("FAIL (aliasing c)\n");
flint_printf("a:\n");
TEMPLATE(T, poly_print) (a, ctx);
flint_printf("\n");
flint_printf("b:\n");
TEMPLATE(T, poly_print) (b, ctx);
flint_printf("\n");
flint_printf("c:\n");
TEMPLATE(T, poly_print) (c, ctx);
flint_printf("\n");
flint_printf("d:\n");
TEMPLATE(T, poly_print) (d, ctx);
flint_printf("\n");
fflush(stdout);
flint_abort();
}
TEMPLATE(T, poly_clear) (a, ctx);
TEMPLATE(T, poly_clear) (b, ctx);
TEMPLATE(T, poly_clear) (c, ctx);
TEMPLATE(T, poly_clear) (d, ctx);
TEMPLATE(T, ctx_clear) (ctx);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
#endif
| /*
Copyright (C) 2011 Fredrik Johansson
Copyright (C) 2012 Lina Kulakova
Copyright (C) 2013 Mike Hansen
This file is part of FLINT.
FLINT is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <https://www.gnu.org/licenses/>.
*/ |
paragraphs.ml |
open Pacomb
let%parser word =
(w::RE"[-a-zA-Z0-9']+") => w
; (p::RE"[.;,:!?]") => p
(* blank with at most one newline for paragraphs *)
let blank1 = Regexp.blank_regexp "[ \t\r]*\n?[ \t\r]*"
(* general blank, no newline, we parse them as separator. *)
let blank2 = Regexp.blank_regexp "[ \t\r]*"
(* for paragraph, we use [Grammar.layout] to change the blank from [blank2] to
[blank1] and we parse with blank1 after the paragraph to read the last
newline at the end of each paragraph, the default would be to parse with
[blank2] only after the paragraph. This way, the minimum number of newline left to
parse as paragraph separation is 1. *)
let%parser
[@layout blank1 ~config:Blank.{ default_layout_config with
new_blanks_after = true
; old_blanks_after = false }]
paragraph = ((p:: ~+ word) => (p, p_pos))
(* paragraph separator, at least one newline *)
let%parser sep = (~+ (CHAR('\n'))) => ()
(* text are list separated by sep and may have initial and final newlines *)
let%parser text = (~? sep) (t:: ~* [sep] paragraph) (~? sep) => t
(* we call the parser *)
let _ =
let t = Pos.handle_exception (Grammar.parse_channel text blank2) stdin in
Printf.printf "%d paragraphs\n%!" (List.length t);
List.iteri (fun i (p,pos) -> Printf.printf " paragraph %d at %a: %d word(s)\n%!"
i
(Pos.print_pos ~style:Short ())
pos
(List.length p)) t
| |
irmin_http.ml |
open Common
open Astring
open! Import
let src = Logs.Src.create "irmin.http" ~doc:"Irmin HTTP REST interface"
module Log = (val Logs.src_log src : Logs.LOG)
module T = Irmin.Type
module Conf = struct
include Irmin.Backend.Conf
let spec = Spec.v "http"
module Key = struct
(* ~uri *)
let uri =
key ~spec ~docv:"URI" ~docs:"COMMON OPTIONS"
~doc:"Location of the remote store." "uri"
Irmin.Type.(option uri)
None
end
end
let config x config =
let a = Conf.empty Conf.spec in
Conf.(verify (union (add a Key.uri (Some x)) config))
let uri_append t path =
match Uri.path t :: path with
| [] -> t
| path ->
let buf = Buffer.create 10 in
List.iter
(function
| "" -> ()
| s ->
if s.[0] <> '/' then Buffer.add_char buf '/';
Buffer.add_string buf s)
path;
let path = Buffer.contents buf in
Uri.with_path t path
let err_no_uri () = invalid_arg "Irmin_http.create: No URI specified"
let get_uri config =
match Conf.(get config Key.uri) with None -> err_no_uri () | Some u -> u
let invalid_arg fmt = Fmt.kstr Lwt.fail_invalid_arg fmt
exception Escape of ((int * int) * (int * int)) * Jsonm.error
let () =
Printexc.register_printer (function
| Escape ((start, end_), err) ->
Fmt.kstr
(fun s -> Some s)
"Escape ({ start = %a; end = %a; error = %a })"
Fmt.(Dump.pair int int)
start
Fmt.(Dump.pair int int)
end_ Jsonm.pp_error err
| _ -> None)
let json_stream (stream : string Lwt_stream.t) : Jsonm.lexeme list Lwt_stream.t
=
let d = Jsonm.decoder `Manual in
let rec lexeme () =
match Jsonm.decode d with
| `Lexeme l -> Lwt.return l
| `Error e -> Lwt.fail (Escape (Jsonm.decoded_range d, e))
| `End -> assert false
| `Await -> (
Lwt_stream.get stream >>= function
| None -> Lwt.fail (Escape (Jsonm.decoded_range d, `Expected `Value))
| Some str ->
Jsonm.Manual.src d (Bytes.of_string str) 0 (String.length str);
lexeme ())
in
let lexemes e =
let lexemes = ref [] in
let objs = ref 0 in
let arrs = ref 0 in
let rec aux () =
let* l = lexeme e in
lexemes := l :: !lexemes;
let () =
match l with
| `Os -> incr objs
| `As -> incr arrs
| `Oe -> decr objs
| `Ae -> decr arrs
| `Name _ | `Null | `Bool _ | `String _ | `Float _ -> ()
in
if !objs > 0 || !arrs > 0 then aux () else Lwt.return_unit
in
let+ () = aux () in
List.rev !lexemes
in
let open_stream () =
lexeme () >>= function
| `As -> Lwt.return_unit
| _ -> Lwt.fail (Escape (Jsonm.decoded_range d, `Expected (`Aval true)))
in
let opened = ref false in
let open_and_get () =
if not !opened then (
open_stream () >>= fun () ->
opened := true;
lexemes () >|= Option.some)
else lexemes () >|= Option.some
in
Lwt_stream.from open_and_get
let of_json = Irmin.Type.of_json_string
let to_json = Irmin.Type.to_json_string
module Helper (Client : Cohttp_lwt.S.Client) :
S.Helper with type ctx = Client.ctx = struct
type ctx = Client.ctx
let err_bad_version v =
invalid_arg "bad server version: expecting %s, but got %s" Irmin.version
(match v with None -> "<none>" | Some v -> v)
let check_version r =
match Cohttp.Header.get (Cohttp.Response.headers r) irmin_version with
| None -> err_bad_version None
| Some v ->
if v <> Irmin.version then err_bad_version (Some v) else Lwt.return_unit
let is_success r =
match Cohttp.Response.status r with `OK -> true | _ -> false
let map_string_response parse (r, b) =
check_version r >>= fun () ->
let* b = Cohttp_lwt.Body.to_string b in
if is_success r then
match parse b with
| Ok x -> Lwt.return x
| Error (`Msg e) ->
Lwt.fail_with (Fmt.str "Error while parsing %S: %s" b e)
else Lwt.fail_with ("Server error: " ^ b)
let map_stream_response t (r, b) =
check_version r >>= fun () ->
if not (is_success r) then
let* b = Cohttp_lwt.Body.to_string b in
Lwt.fail_with ("Server error: " ^ b)
else
let stream = Cohttp_lwt.Body.to_stream b in
let stream = json_stream stream in
let stream =
let aux j =
match T.decode_json_lexemes t j with
| Error (`Msg e) -> Lwt.fail_with e
| Ok c -> Lwt.return c
in
Lwt_stream.map_s aux stream
in
Lwt.return stream
let headers ~keep_alive () =
let keep_alive =
if keep_alive then [ ("Connection", "Keep-Alive") ] else []
in
Cohttp.Header.of_list
([ (irmin_version, Irmin.version); ("Content-type", "application/json") ]
@ keep_alive)
let map_call meth t ctx ~keep_alive ?body path fn =
let uri = uri_append t path in
let body = match body with None -> None | Some b -> Some (`String b) in
let headers = headers ~keep_alive () in
[%log.debug "%s %s" (Cohttp.Code.string_of_method meth) (Uri.path uri)];
Lwt.catch
(fun () -> Client.call ?ctx meth ~headers ?body uri >>= fn)
(fun e ->
[%log.debug "request to %a failed: %a" Uri.pp_hum uri Fmt.exn e];
Lwt.fail e)
let call meth t ctx ?body path parse =
map_call meth t ctx ~keep_alive:false ?body path (map_string_response parse)
let call_stream meth t ctx ?body path parse =
map_call meth t ctx ~keep_alive:true ?body path (map_stream_response parse)
end
module RO (Client : Cohttp_lwt.S.Client) (K : Irmin.Type.S) (V : Irmin.Type.S) :
S.Read_only.S
with type ctx = Client.ctx
and type key = K.t
and type value = V.t = struct
type ctx = Client.ctx
module HTTP = Helper (Client)
type 'a t = {
uri : Uri.t;
item : string;
items : string;
ctx : Client.ctx option;
}
let uri t = t.uri
let item t = t.item
let items t = t.items
let close _ = Lwt.return ()
type key = K.t
type value = V.t
let key_str = Irmin.Type.to_string K.t
let val_of_str = Irmin.Type.of_string V.t
let find t key =
HTTP.map_call `GET t.uri t.ctx ~keep_alive:false
[ t.item; key_str key ]
(fun ((r, _) as x) ->
if Cohttp.Response.status r = `Not_found then Lwt.return_none
else HTTP.map_string_response val_of_str x >|= Option.some)
let mem t key =
HTTP.map_call `GET t.uri t.ctx ~keep_alive:false
[ t.item; key_str key ]
(fun (r, _) ->
if Cohttp.Response.status r = `Not_found then Lwt.return_false
else Lwt.return_true)
let v ?ctx uri item items = Lwt.return { uri; item; items; ctx }
end
module CA (Client : Cohttp_lwt.S.Client) (H : Irmin.Hash.S) (V : Irmin.Type.S) =
struct
include RO (Client) (H) (V)
let add t value =
let body = Irmin.Type.to_string V.t value in
HTTP.call `POST t.uri t.ctx [ t.items ] ~body (Irmin.Type.of_string H.t)
let unsafe_add t key value =
let body = Irmin.Type.to_string V.t value in
HTTP.call `POST t.uri t.ctx
[ "unsafe"; t.items; key_str key ]
~body
Irmin.Type.(of_string unit)
let cast t = (t :> read_write t)
let batch t f =
(* TODO:cache the writes locally and send everything in one batch *)
f (cast t)
let close _ = Lwt.return_unit
end
module RW : S.Atomic_write.Maker =
functor
(Client : Cohttp_lwt.S.Client)
(K : Irmin.Type.S)
(V : Irmin.Type.S)
->
struct
module RO = RO (Client) (K) (V)
module HTTP = RO.HTTP
module W = Irmin.Backend.Watch.Make (K) (V)
type key = RO.key
type value = RO.value
type watch = W.watch
type ctx = Client.ctx
(* cache the stream connections to the server: we open only one
connection per stream kind. *)
type cache = { mutable stop : unit -> unit }
let empty_cache () = { stop = (fun () -> ()) }
type t = { t : read RO.t; w : W.t; keys : cache; glob : cache }
let get t = HTTP.call `GET (RO.uri t.t) t.t.ctx
let put t = HTTP.call `PUT (RO.uri t.t) t.t.ctx
let get_stream t = HTTP.call_stream `GET (RO.uri t.t) t.t.ctx
let post_stream t = HTTP.call_stream `POST (RO.uri t.t) t.t.ctx
let v ?ctx uri item items =
let* t = RO.v ?ctx uri item items in
let w = W.v () in
let keys = empty_cache () in
let glob = empty_cache () in
Lwt.return { t; w; keys; glob }
let find t = RO.find t.t
let mem t = RO.mem t.t
let key_str = Irmin.Type.to_string K.t
let list t = get t [ RO.items t.t ] (of_json T.(list K.t))
let set t key value =
let value = { v = Some value; set = None; test = None } in
let body = to_json (set_t V.t) value in
put t [ RO.item t.t; key_str key ] ~body (of_json status_t) >>= function
| { status = "ok" } -> Lwt.return_unit
| e -> Lwt.fail_with e.status
let test_and_set t key ~test ~set =
let value = { v = None; set; test } in
let body = to_json (set_t V.t) value in
put t [ RO.item t.t; key_str key ] ~body (of_json status_t) >>= function
| { status = "true" } -> Lwt.return_true
| { status = "false" } -> Lwt.return_false
| e -> Lwt.fail_with e.status
let pp_key = Irmin.Type.pp K.t
let remove t key =
HTTP.map_call `DELETE (RO.uri t.t) t.t.ctx ~keep_alive:false
[ RO.item t.t; key_str key ]
(fun (r, b) ->
match Cohttp.Response.status r with
| `Not_found | `OK -> Lwt.return_unit
| _ ->
let* b = Cohttp_lwt.Body.to_string b in
Fmt.kstr Lwt.fail_with "cannot remove %a: %s" pp_key key b)
let nb_keys t = fst (W.stats t.w)
let nb_glob t = snd (W.stats t.w)
(* run [t] and returns an handler to stop the task. *)
let stoppable t =
let s, u = Lwt.task () in
Lwt.async (fun () -> Lwt.pick [ s; t () ]);
function () -> Lwt.wakeup u ()
let watch_key t key ?init f =
let key_str = Irmin.Type.to_string K.t key in
let init_stream () =
if nb_keys t <> 0 then Lwt.return_unit
else
let* s =
match init with
| None -> get_stream t [ "watch"; key_str ] (event_t K.t V.t)
| Some init ->
let body = to_json V.t init in
post_stream t [ "watch"; key_str ] ~body (event_t K.t V.t)
in
let stop () =
Lwt_stream.iter_s
(fun { diff; _ } ->
let diff =
match diff with
| `Removed _ -> None
| `Added v | `Updated (_, v) -> Some v
in
W.notify t.w key diff)
s
in
t.keys.stop <- stoppable stop;
Lwt.return_unit
in
let* () = init_stream () in
W.watch_key t.w key ?init f
let watch t ?init f =
let init_stream () =
if nb_glob t <> 0 then Lwt.return_unit
else
let* s =
match init with
| None -> get_stream t [ "watches" ] (event_t K.t V.t)
| Some init ->
let init =
List.map (fun (branch, commit) -> { branch; commit }) init
in
let body = to_json T.(list (init_t K.t V.t)) init in
post_stream t [ "watches" ] ~body (event_t K.t V.t)
in
let stop () =
Lwt_stream.iter_s
(fun ev ->
let diff =
match ev.diff with
| `Removed _ -> None
| `Added v | `Updated (_, v) -> Some v
in
let k = ev.branch in
[%log.debug fun l ->
let pp_opt =
Fmt.option ~none:(Fmt.any "<none>") (Irmin.Type.pp V.t)
in
l "notify %a: %a" pp_key k pp_opt diff]
;
W.notify t.w k diff)
s
in
t.glob.stop <- stoppable stop;
Lwt.return_unit
in
let* () = init_stream () in
W.watch t.w ?init f
let stop x =
let () = try x.stop () with _e -> () in
x.stop <- (fun () -> ())
let unwatch t id =
W.unwatch t.w id >>= fun () ->
if nb_keys t = 0 then stop t.keys;
if nb_glob t = 0 then stop t.glob;
Lwt.return_unit
let close _ = Lwt.return_unit
let clear t =
HTTP.call `POST t.t.uri t.t.ctx [ "clear"; t.t.items ]
Irmin.Type.(of_string unit)
end
module type HTTP_CLIENT = sig
include Cohttp_lwt.S.Client
val ctx : unit -> ctx option
end
module Client (Client : HTTP_CLIENT) (S : Irmin.S) = struct
module X = struct
module Hash = S.Hash
module Schema = S.Schema
module Key = Irmin.Key.Of_hash (Hash)
module Contents = struct
module X = struct
module Key = S.Hash
module Val = S.Contents
module CA = CA (Client) (Key) (Val)
include Closeable.Content_addressable (CA)
end
include Irmin.Contents.Store (X) (X.Key) (X.Val)
let v ?ctx config = X.v ?ctx config "blob" "blobs"
end
module Node = struct
module Val = S.Backend.Node.Val
module Hash = Irmin.Hash.Typed (S.Hash) (Val)
module CA = CA (Client) (S.Hash) (Val)
include Irmin.Indexable.Of_content_addressable (S.Hash) (CA)
module Contents = Contents
module Metadata = S.Metadata
module Path = S.Path
let merge (t : _ t) =
let f ~(old : Key.t option Irmin.Merge.promise) left right =
let* old =
old () >|= function
| Ok (Some old) -> old
| Ok None -> None
| Error _ -> None
in
let body =
Irmin.Type.(to_string (merge_t (option Key.t))) { old; left; right }
in
let result = merge_result_t Key.t in
CA.HTTP.call `POST t.uri t.ctx [ t.items; "merge" ] ~body
(Irmin.Type.of_string result)
in
Irmin.Merge.(v Irmin.Type.(option Key.t)) f
let v ?ctx config = CA.v ?ctx config "tree" "trees"
end
module Node_portable = Irmin.Node.Portable.Of_node (Node.Val)
module Commit = struct
module X = struct
module Key = S.Hash
module Val = struct
include S.Backend.Commit.Val
module Info = S.Info
type hash = S.Hash.t [@@deriving irmin]
end
module CA = CA (Client) (Key) (Val)
include Closeable.Content_addressable (CA)
end
include Irmin.Commit.Store (S.Info) (Node) (X) (X.Key) (X.Val)
let v ?ctx config = X.v ?ctx config "commit" "commits"
end
module Commit_portable = Irmin.Commit.Portable.Of_commit (Commit.X.Val)
module Slice = Irmin.Backend.Slice.Make (Contents) (Node) (Commit)
module Remote = Irmin.Backend.Remote.None (Hash) (S.Branch)
module Branch = struct
module Key = S.Branch
module Val = Commit.Key
include Closeable.Atomic_write (RW (Client) (Key) (S.Hash))
let v ?ctx config = v ?ctx config "branch" "branches"
end
module Repo = struct
type t = {
config : Irmin.config;
contents : read Contents.t;
node : read Node.t;
commit : read Commit.t;
branch : Branch.t;
}
let branch_t t = t.branch
let commit_t t = t.commit
let node_t t = t.node
let contents_t t = t.contents
let config t = t.config
let batch t f =
Contents.X.batch t.contents @@ fun contents_t ->
Node.batch t.node @@ fun node_t ->
Commit.X.batch (snd t.commit) @@ fun commit_t ->
let commit_t = (node_t, commit_t) in
f contents_t node_t commit_t
let v config =
let uri = get_uri config in
let ctx = Client.ctx () in
let* contents = Contents.v ?ctx uri in
let* node = Node.v ?ctx uri in
let* commit = Commit.v ?ctx uri in
let+ branch = Branch.v ?ctx uri in
let commit = (node, commit) in
{ contents; node; commit; branch; config }
let close t =
let* () = Contents.X.close t.contents in
let* () = Branch.close t.branch in
Commit.X.close (snd t.commit)
end
end
include Irmin.Of_backend (X)
end
module type SERVER = Irmin_http_server.S
module Server = Irmin_http_server.Make
| (*
* Copyright (c) 2013-2021 Thomas Gazagnaire <thomas@gazagnaire.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*) |
pb_plugin.ml |
module M = Protoc_messages
module G = Protobuf_reified.Generate
(** Error handling *)
exception Error of string
let failf fmt = Printf.kprintf (fun s -> raise (Error s)) fmt
let warnf fmt = Printf.fprintf stderr ("Warning: " ^^ fmt ^^ "\n")
let is_some = function Some _ -> true | _ -> false
let iter_opt f = function Some x -> f x | None -> ()
let map_opt f = function Some x -> Some (f x) | None -> None
let basename s =
let last = pred (String.length s) in
match String.rindex_from s last '.' with
i -> String.sub s (succ i) (last - i)
| exception Not_found -> s
module Context :
sig
type t
val create : package:string option -> t
val enum : t -> string -> G.enum
(** hash-consed enums *)
val message : t -> string -> G.message
(** hash-consed messages *)
val write_ml : Format.formatter -> t -> unit
(** write out the contents of the context as an OCaml module *)
end =
struct
type t = {
package: string option;
enums: (string, G.enum) Hashtbl.t;
messages: (string, G.message) Hashtbl.t;
}
let create ~package =
{ package;
messages = Hashtbl.create 10;
enums = Hashtbl.create 10 }
let message {messages; _} s =
let s = basename s in
match Hashtbl.find messages s with
| m -> m
| exception Not_found ->
let m = G.message s in (Hashtbl.add messages s m; m)
let enum {enums; _} s =
let s = basename s in
match Hashtbl.find enums s with
| e -> e
| exception Not_found ->
let e = G.enum s in (Hashtbl.add enums s e; e)
let write_ml fmt { package=_ ; enums ; messages } =
(* TODO: package? *)
let as_list h = Hashtbl.fold (fun _ -> List.cons) h [] in
G.write fmt (as_list messages) (as_list enums)
end
module Enum :
sig
val generate : Context.t -> M.EnumDescriptorProto.s -> unit
end =
struct
module EVO = M.EnumValueOptions
let handle_option { EVO.deprecated; uninterpreted_option=_ } =
if deprecated
then warnf "ignoring option deprecated";
module EV = M.EnumValueDescriptorProto
let genenum_value e = function
| { EV.name = None; _ } -> failf "nameless enum values are not supported"
| { EV.number = None; _ } -> failf "numberless enum values are not supported"
| { EV.name = Some name; number = Some number; options } ->
iter_opt handle_option options;
G.constant name e number
module E = M.EnumDescriptorProto
let handle_option { M.EnumOptions.allow_alias; deprecated; uninterpreted_option=_ } =
begin
if is_some allow_alias
then warnf "ignoring option allow_alias";
if deprecated
then warnf "ignoring option deprecated";
end
let generate context = function
| { E.name = None; _ } -> failf "nameless enum values are not supported"
| { E.name = Some name; value; options } ->
iter_opt handle_option options;
let e = Context.enum context name in
List.iter (genenum_value e) value
end
module Message :
sig
val generate : Context.t -> M.DescriptorProto.s -> unit
end =
struct
let gentype context t name =
match M.Type.T.of_value (Pb.constant_value t), name with
| `TYPE_DOUBLE, _ -> G.double
| `TYPE_FLOAT, _ -> G.float
| `TYPE_INT64, _ -> G.int64
| `TYPE_UINT64, _ -> G.uint64
| `TYPE_INT32, _ -> G.int32
| `TYPE_FIXED64, _ -> G.fixed64
| `TYPE_FIXED32, _ -> G.fixed32
| `TYPE_BOOL, _ -> G.bool
| `TYPE_STRING, _ -> G.string
| `TYPE_GROUP, _ -> failf "groups are not supported"
| `TYPE_MESSAGE, None -> failf "message fields without names are not supported"
| `TYPE_MESSAGE, Some m -> G.message_field (Context.message context m)
| `TYPE_BYTES, _ -> G.bytes
| `TYPE_UINT32, _ -> G.uint32
| `TYPE_ENUM, None -> failf "enum fields without names are not supported"
| `TYPE_ENUM, Some e -> G.enum_field (Context.enum context e)
| `TYPE_SFIXED32, _ -> G.sfixed32
| `TYPE_SFIXED64, _ -> G.sfixed64
| `TYPE_SINT32, _ -> G.sint32
| `TYPE_SINT64, _ -> G.sint64
module FO = M.FieldOptions
let handle_option { FO.ctype=_; FO.packed; FO.jstype=_; FO.lazy_; FO.deprecated; FO.weak;
FO.uninterpreted_option=_ } =
begin
if is_some packed
then warnf "ignoring option packed";
if is_some packed
then warnf "ignoring option packed";
if lazy_
then warnf "ignoring option lazy";
if deprecated
then warnf "ignoring option deprecated";
if weak
then warnf "ignoring option weak";
end
module F = M.FieldDescriptorProto
let genfield context msg = function
| { F.name = None; _ } -> failf "nameless message fields not supported"
| { F.number = None; _ } -> failf "numberless message fields not supported"
| { F.type_ = None; _ } -> failf "typeless message fields not supported"
| { F.name = Some name; number = Some number; label; type_ = Some type_; type_name;
extendee; default_value; oneof_index; options; json_name=_ } as _r ->
iter_opt handle_option options;
begin
if is_some extendee
then warnf "ignoring extendee";
if is_some oneof_index
then warnf "ignoring oneof_index";
end;
let labelf = match label with
None -> G.required
| Some l -> match M.Label.T.of_value (Pb.constant_value l) with
| `LABEL_REQUIRED -> G.required
| `LABEL_REPEATED -> G.repeated
| `LABEL_OPTIONAL ->
begin match default_value with
| Some default -> G.optional ~default
| None -> G.optional ?default:None
end
in
let typ = gentype context type_ type_name in
labelf name msg typ number
module MO = M.MessageOptions
let handle_options { MO.message_set_wire_format;
no_standard_descriptor_accessor;
deprecated: bool;
map_entry;
uninterpreted_option=_ } =
begin
if message_set_wire_format
then warnf "ignoring option message_set_wire_format";
if no_standard_descriptor_accessor
then warnf "ignoring option no_standard_descriptor_accessor";
if deprecated
then warnf "ignoring option deprecated";
if is_some map_entry
then warnf "ignoring option map_entry";
end
module D = M.DescriptorProto
let generate context = function
| { D.name = None; _ } -> failf "nameless messages not supported"
| { D.name = Some name; field; extension; nested_type; enum_type;
extension_range; oneof_decl; options; reserved_range; reserved_name } ->
begin
List.iter (fun _ -> failf "extension entries unsupported") extension;
List.iter (fun _ -> failf "nested types unsupported") nested_type;
List.iter (fun _ -> failf "nested enums unsupported") enum_type;
List.iter (fun _ -> failf "extension ranges unsupported") extension_range;
List.iter (fun _ -> failf "oneof declarations unsupported") oneof_decl;
List.iter (fun _ -> failf "reserved ranges unsupported") reserved_range;
List.iter (fun _ -> failf "reserved names unsupported") reserved_name;
iter_opt handle_options options;
let msg = Context.message context name in
List.iter (genfield context msg) field
end
end
let generate1 _input_file
{ M.FileDescriptorProto.name; enum_type; message_type; service; package;
dependency=_; (* ? *)
public_dependency=_; (* ? *)
weak_dependency=_; (* ? *)
extension=_; (* ? *)
options=_; (* ? *)
source_code_info=_; (* Locations *)
syntax=_ (* protobuf syntax version (e.g. proto3) *) } :
M.File.T.m Pb.msg =
begin
let context = Context.create ~package in
begin match service with [] -> () | _ :: _ -> failf "Services not yet supported" end;
List.iter (Enum.generate context) enum_type;
let () = List.iter (Message.generate context) message_type in
let name = map_opt
(fun c -> Filename.chop_extension c ^ ".ml") name in
M.File.mk ?name
~content:(Format.asprintf "%a" Context.write_ml context)
()
end
let generate files proto_files =
match List.combine files proto_files with
| [(file, proto_file)] -> [generate1 file proto_file]
| [] -> failf "error: exactly one filename (not zero) must be specified"
| _::_::_ -> failf "error: exactly one filename (not more) must be specified"
| exception Invalid_argument _ ->
failf "Mismatched lengths: %d files, %d proto_files"
(List.length files)
(List.length proto_files)
let run msg =
let { M.CodeGeneratorRequest.file_to_generate;
proto_file; parameter=_; compiler_version=_ } =
M.CodeGeneratorRequest.extract msg
in
match generate file_to_generate proto_file with
| files ->
M.CodeGeneratorResponse.mk ~file:files ()
| exception (Error s) ->
M.CodeGeneratorResponse.mk ~file:[] ~error:s ()
let main () =
let stdin_buf = BatIO.(read_all stdin) in
match Angstrom.parse_string (Pb.read M.CodeGeneratorRequest.T.t) stdin_buf with
Result.Error e -> failf "Error parssing request: %s" e
| Result.Ok msg -> print_string (Faraday.serialize_to_string
(Pb.write (run msg)))
let () = main ()
| (*
* Copyright (c) 2017 Jeremy Yallop <yallop@docker.com>.
*
* This file is distributed under the terms of the MIT License.
* See the file LICENSE for details.
*) |
vlib.ml |
let run () = Printf.printf "hi from lib.default" | |
clang_stubs.c | /* This file is auto-generated by stubgen tool.
* It should not be modified by hand and it should not be versioned
* (except by continuous integration on the dedicated bootstrap branch). */
#include "stubgen.h"
#include <clang-c/Index.h>
#include "clang__custom.h"
#include "libclang_extensions.h"
CAMLprim value
clang_getBuildSessionTimestamp_wrapper()
{
CAMLparam0();
unsigned long long result = clang_getBuildSessionTimestamp();
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
static void finalize_cxvirtualfileoverlay(value v) {
clang_VirtualFileOverlay_dispose(*((CXVirtualFileOverlay *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(CXVirtualFileOverlay, cxvirtualfileoverlay, Cxvirtualfileoverlay_val, Val_cxvirtualfileoverlay, finalize_cxvirtualfileoverlay, custom_compare_default, custom_hash_default)
CAMLprim value
clang_VirtualFileOverlay_create_wrapper(value options_ocaml)
{
CAMLparam1(options_ocaml);
unsigned int options;
options = Int_val(options_ocaml);
CXVirtualFileOverlay result = clang_VirtualFileOverlay_create(options);
{
CAMLlocal1(data);
data = Val_cxvirtualfileoverlay(result);
CAMLreturn(data);
}
}
enum CXErrorCode
Cxerrorcode_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXError_Failure;
case 1: return CXError_Crashed;
case 2: return CXError_InvalidArguments;
case 3: return CXError_ASTReadError;
}
caml_failwith_fmt("invalid value for Cxerrorcode_val: %d", Int_val(ocaml));
return CXError_Failure;
}
value
Val_cxerrorcode(enum CXErrorCode v)
{
switch (v) {
case CXError_Failure: return Val_int(0);
case CXError_Crashed: return Val_int(1);
case CXError_InvalidArguments: return Val_int(2);
case CXError_ASTReadError: return Val_int(3);
case CXError_Success: caml_failwith("unexpected success value");
}
caml_failwith_fmt("invalid value for Val_cxerrorcode: %d", v);
return Val_int(0);
}
CAMLprim value
clang_VirtualFileOverlay_addFileMapping_wrapper(value arg_ocaml, value virtualPath_ocaml, value realPath_ocaml)
{
CAMLparam3(arg_ocaml, virtualPath_ocaml, realPath_ocaml);
CXVirtualFileOverlay arg;
arg = Cxvirtualfileoverlay_val(arg_ocaml);
const char * virtualPath;
virtualPath = String_val(virtualPath_ocaml);
const char * realPath;
realPath = String_val(realPath_ocaml);
enum CXErrorCode result = clang_VirtualFileOverlay_addFileMapping(arg, virtualPath, realPath);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_unit;
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_VirtualFileOverlay_setCaseSensitivity_wrapper(value arg_ocaml, value caseSensitive_ocaml)
{
CAMLparam2(arg_ocaml, caseSensitive_ocaml);
CXVirtualFileOverlay arg;
arg = Cxvirtualfileoverlay_val(arg_ocaml);
int caseSensitive;
caseSensitive = Int_val(caseSensitive_ocaml);
enum CXErrorCode result = clang_VirtualFileOverlay_setCaseSensitivity(arg, caseSensitive);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_unit;
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_VirtualFileOverlay_writeToBuffer_wrapper(value arg_ocaml, value options_ocaml)
{
CAMLparam2(arg_ocaml, options_ocaml);
CXVirtualFileOverlay arg;
arg = Cxvirtualfileoverlay_val(arg_ocaml);
unsigned int options;
options = Int_val(options_ocaml);
unsigned int out_buffer_size;
char * out_buffer_ptr;
enum CXErrorCode result = clang_VirtualFileOverlay_writeToBuffer(arg, options, &out_buffer_ptr, &out_buffer_size);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = caml_alloc_initialized_string(out_buffer_size, out_buffer_ptr);
free(out_buffer_ptr);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
static void finalize_cxmodulemapdescriptor(value v) {
clang_ModuleMapDescriptor_dispose(*((CXModuleMapDescriptor *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(CXModuleMapDescriptor, cxmodulemapdescriptor, Cxmodulemapdescriptor_val, Val_cxmodulemapdescriptor, finalize_cxmodulemapdescriptor, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ModuleMapDescriptor_create_wrapper(value options_ocaml)
{
CAMLparam1(options_ocaml);
unsigned int options;
options = Int_val(options_ocaml);
CXModuleMapDescriptor result = clang_ModuleMapDescriptor_create(options);
{
CAMLlocal1(data);
data = Val_cxmodulemapdescriptor(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ModuleMapDescriptor_setFrameworkModuleName_wrapper(value arg_ocaml, value name_ocaml)
{
CAMLparam2(arg_ocaml, name_ocaml);
CXModuleMapDescriptor arg;
arg = Cxmodulemapdescriptor_val(arg_ocaml);
const char * name;
name = String_val(name_ocaml);
enum CXErrorCode result = clang_ModuleMapDescriptor_setFrameworkModuleName(arg, name);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_unit;
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_ModuleMapDescriptor_setUmbrellaHeader_wrapper(value arg_ocaml, value name_ocaml)
{
CAMLparam2(arg_ocaml, name_ocaml);
CXModuleMapDescriptor arg;
arg = Cxmodulemapdescriptor_val(arg_ocaml);
const char * name;
name = String_val(name_ocaml);
enum CXErrorCode result = clang_ModuleMapDescriptor_setUmbrellaHeader(arg, name);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_unit;
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_ModuleMapDescriptor_writeToBuffer_wrapper(value arg_ocaml, value options_ocaml)
{
CAMLparam2(arg_ocaml, options_ocaml);
CXModuleMapDescriptor arg;
arg = Cxmodulemapdescriptor_val(arg_ocaml);
unsigned int options;
options = Int_val(options_ocaml);
unsigned int out_buffer_size;
char * out_buffer_ptr;
enum CXErrorCode result = clang_ModuleMapDescriptor_writeToBuffer(arg, options, &out_buffer_ptr, &out_buffer_size);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = caml_alloc_initialized_string(out_buffer_size, out_buffer_ptr);
free(out_buffer_ptr);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
static void finalize_cxindex(value v) {
clang_disposeIndex(*((CXIndex *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(CXIndex, cxindex, Cxindex_val, Val_cxindex, finalize_cxindex, custom_compare_default, custom_hash_default)
CAMLprim value
clang_createIndex_wrapper(value excludeDeclarationsFromPCH_ocaml, value displayDiagnostics_ocaml)
{
CAMLparam2(excludeDeclarationsFromPCH_ocaml, displayDiagnostics_ocaml);
int excludeDeclarationsFromPCH;
excludeDeclarationsFromPCH = Bool_val(excludeDeclarationsFromPCH_ocaml);
int displayDiagnostics;
displayDiagnostics = Bool_val(displayDiagnostics_ocaml);
CXIndex result = clang_createIndex(excludeDeclarationsFromPCH, displayDiagnostics);
{
CAMLlocal1(data);
data = Val_cxindex(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXIndex_setGlobalOptions_wrapper(value arg_ocaml, value options_ocaml)
{
CAMLparam2(arg_ocaml, options_ocaml);
CXIndex arg;
arg = Cxindex_val(arg_ocaml);
unsigned int options;
options = Int_val(options_ocaml);
clang_CXIndex_setGlobalOptions(arg, options);
CAMLreturn(Val_unit);
}
CAMLprim value
clang_CXIndex_getGlobalOptions_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXIndex arg;
arg = Cxindex_val(arg_ocaml);
unsigned int result = clang_CXIndex_getGlobalOptions(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXIndex_setInvocationEmissionPathOption_wrapper(value arg_ocaml, value Path_ocaml)
{
CAMLparam2(arg_ocaml, Path_ocaml);
CXIndex arg;
arg = Cxindex_val(arg_ocaml);
const char * Path;
Path = String_val(Path_ocaml);
clang_CXIndex_setInvocationEmissionPathOption(arg, Path);
CAMLreturn(Val_unit);
}
DECLARE_OPAQUE_EX(CXFile, cxfile, Cxfile_val, Val_cxfile, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getFileName_wrapper(value SFile_ocaml)
{
CAMLparam1(SFile_ocaml);
CXFile SFile;
SFile = Cxfile_val(Field(SFile_ocaml, 0));
CXString result = clang_getFileName(SFile);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getFileTime_wrapper(value SFile_ocaml)
{
CAMLparam1(SFile_ocaml);
CXFile SFile;
SFile = Cxfile_val(Field(SFile_ocaml, 0));
time_t result = clang_getFileTime(SFile);
{
CAMLlocal1(data);
data = Val_int((int) result);
CAMLreturn(data);
}
}
static value __attribute__((unused))
Val_cxfileuniqueid(CXFileUniqueID v)
{
CAMLparam0();
CAMLlocal1(data);
data = caml_alloc_tuple(3);
CAMLlocal1(field);
for (size_t i = 0; i < 3; i++) {
field = Val_int(v.data[i]);
Store_field(data, i, field);
}
CAMLreturn(data);
}
static CXFileUniqueID __attribute__((unused))
Cxfileuniqueid_val(value ocaml)
{
CAMLparam1(ocaml);
CXFileUniqueID v;
CAMLlocal1(ocaml_field);
for (size_t i = 0; i < 3; i++) {
unsigned long long field;
ocaml_field = Field(ocaml, i);
field = Int_val(ocaml_field);
v.data[i] = field;
}
CAMLreturnT(CXFileUniqueID, v);
}
CAMLprim value
clang_getFileUniqueID_wrapper(value file_ocaml)
{
CAMLparam1(file_ocaml);
CXFile file;
file = Cxfile_val(Field(file_ocaml, 0));
CXFileUniqueID outID;
int result = clang_getFileUniqueID(file, &outID);
if (!result) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_cxfileuniqueid(outID);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLreturn(Val_int(0));
}}
static void finalize_cxtranslationunit(value v) {
clang_disposeTranslationUnit(*((CXTranslationUnit *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(CXTranslationUnit, cxtranslationunit, Cxtranslationunit_val, Val_cxtranslationunit, finalize_cxtranslationunit, custom_compare_default, custom_hash_default)
CAMLprim value
clang_isFileMultipleIncludeGuarded_wrapper(value tu_ocaml, value file_ocaml)
{
CAMLparam2(tu_ocaml, file_ocaml);
CXTranslationUnit tu;
tu = Cxtranslationunit_val(Field(tu_ocaml, 0));
CXFile file;
file = Cxfile_val(Field(file_ocaml, 0));
unsigned int result = clang_isFileMultipleIncludeGuarded(tu, file);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getFile_wrapper(value tu_ocaml, value file_name_ocaml)
{
CAMLparam2(tu_ocaml, file_name_ocaml);
CXTranslationUnit tu;
tu = Cxtranslationunit_val(Field(tu_ocaml, 0));
const char * file_name;
file_name = String_val(file_name_ocaml);
CXFile result = clang_getFile(tu, file_name);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxfile(result));
Store_field(data, 1, tu_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_getFileContents_wrapper(value tu_ocaml, value file_ocaml)
{
CAMLparam2(tu_ocaml, file_ocaml);
CXTranslationUnit tu;
tu = Cxtranslationunit_val(Field(tu_ocaml, 0));
CXFile file;
file = Cxfile_val(Field(file_ocaml, 0));
size_t size;
const char * result = clang_getFileContents(tu, file, &size);
{
CAMLlocal1(data);
if (result == NULL) {
data = Val_int(0);
}
else {
CAMLlocal1(option_value);
option_value = caml_alloc_initialized_string(size, result);
data = caml_alloc(1, 0);
Store_field(data, 0, option_value);
};
CAMLreturn(data);
}
}
CAMLprim value
clang_File_isEqual_wrapper(value file1_ocaml, value file2_ocaml)
{
CAMLparam2(file1_ocaml, file2_ocaml);
CXFile file1;
file1 = Cxfile_val(Field(file1_ocaml, 0));
CXFile file2;
file2 = Cxfile_val(Field(file2_ocaml, 0));
int result = clang_File_isEqual(file1, file2);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_File_tryGetRealPathName_wrapper(value file_ocaml)
{
CAMLparam1(file_ocaml);
CXFile file;
file = Cxfile_val(Field(file_ocaml, 0));
CXString result = clang_File_tryGetRealPathName(file);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXSourceLocation, cxsourcelocation, Cxsourcelocation_val, Val_cxsourcelocation, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getNullLocation_wrapper()
{
CAMLparam0();
CXSourceLocation result = clang_getNullLocation();
{
CAMLlocal1(data);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxsourcelocation(result));
CAMLreturn(data);
}
}
CAMLprim value
clang_equalLocations_wrapper(value loc1_ocaml, value loc2_ocaml)
{
CAMLparam2(loc1_ocaml, loc2_ocaml);
CXSourceLocation loc1;
loc1 = Cxsourcelocation_val(Field(loc1_ocaml, 0));
CXSourceLocation loc2;
loc2 = Cxsourcelocation_val(Field(loc2_ocaml, 0));
unsigned int result = clang_equalLocations(loc1, loc2);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getLocation_wrapper(value tu_ocaml, value file_ocaml, value line_ocaml, value column_ocaml)
{
CAMLparam4(tu_ocaml, file_ocaml, line_ocaml, column_ocaml);
CXTranslationUnit tu;
tu = Cxtranslationunit_val(Field(tu_ocaml, 0));
CXFile file;
file = Cxfile_val(Field(file_ocaml, 0));
unsigned int line;
line = Int_val(line_ocaml);
unsigned int column;
column = Int_val(column_ocaml);
CXSourceLocation result = clang_getLocation(tu, file, line, column);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcelocation(result));
Store_field(data, 1, tu_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_getLocationForOffset_wrapper(value tu_ocaml, value file_ocaml, value offset_ocaml)
{
CAMLparam3(tu_ocaml, file_ocaml, offset_ocaml);
CXTranslationUnit tu;
tu = Cxtranslationunit_val(Field(tu_ocaml, 0));
CXFile file;
file = Cxfile_val(Field(file_ocaml, 0));
unsigned int offset;
offset = Int_val(offset_ocaml);
CXSourceLocation result = clang_getLocationForOffset(tu, file, offset);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcelocation(result));
Store_field(data, 1, tu_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_Location_isInSystemHeader_wrapper(value location_ocaml)
{
CAMLparam1(location_ocaml);
CXSourceLocation location;
location = Cxsourcelocation_val(Field(location_ocaml, 0));
int result = clang_Location_isInSystemHeader(location);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Location_isFromMainFile_wrapper(value location_ocaml)
{
CAMLparam1(location_ocaml);
CXSourceLocation location;
location = Cxsourcelocation_val(Field(location_ocaml, 0));
int result = clang_Location_isFromMainFile(location);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXSourceRange, cxsourcerange, Cxsourcerange_val, Val_cxsourcerange, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getNullRange_wrapper()
{
CAMLparam0();
CXSourceRange result = clang_getNullRange();
{
CAMLlocal1(data);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxsourcerange(result));
CAMLreturn(data);
}
}
CAMLprim value
clang_getRange_wrapper(value begin_ocaml, value end_ocaml)
{
CAMLparam2(begin_ocaml, end_ocaml);
CXSourceLocation begin;
begin = Cxsourcelocation_val(Field(begin_ocaml, 0));
CXSourceLocation end;
end = Cxsourcelocation_val(Field(end_ocaml, 0));
CXSourceRange result = clang_getRange(begin, end);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcerange(result));
Store_field(data, 1, safe_field(begin_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_equalRanges_wrapper(value range1_ocaml, value range2_ocaml)
{
CAMLparam2(range1_ocaml, range2_ocaml);
CXSourceRange range1;
range1 = Cxsourcerange_val(Field(range1_ocaml, 0));
CXSourceRange range2;
range2 = Cxsourcerange_val(Field(range2_ocaml, 0));
unsigned int result = clang_equalRanges(range1, range2);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Range_isNull_wrapper(value range_ocaml)
{
CAMLparam1(range_ocaml);
CXSourceRange range;
range = Cxsourcerange_val(Field(range_ocaml, 0));
int result = clang_Range_isNull(range);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getExpansionLocation_wrapper(value location_ocaml)
{
CAMLparam1(location_ocaml);
CXSourceLocation location;
location = Cxsourcelocation_val(Field(location_ocaml, 0));
CXFile file;
unsigned int line;
unsigned int column;
unsigned int offset;
clang_getExpansionLocation(location, &file, &line, &column, &offset);
{
CAMLlocal1(data);
data = caml_alloc_tuple(4);
{
CAMLlocal1(field);
field = caml_alloc_tuple(1);
Store_field(field, 0, Val_cxfile(file));
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = Val_int(line);
Store_field(data, 1, field);
}
{
CAMLlocal1(field);
field = Val_int(column);
Store_field(data, 2, field);
}
{
CAMLlocal1(field);
field = Val_int(offset);
Store_field(data, 3, field);
}
CAMLreturn(data);
}
}
CAMLprim value
clang_getPresumedLocation_wrapper(value location_ocaml)
{
CAMLparam1(location_ocaml);
CXSourceLocation location;
location = Cxsourcelocation_val(Field(location_ocaml, 0));
CXString filename;
unsigned int line;
unsigned int column;
clang_getPresumedLocation(location, &filename, &line, &column);
{
CAMLlocal1(data);
data = caml_alloc_tuple(3);
{
CAMLlocal1(field);
field = caml_copy_string(safe_string(clang_getCString(filename)));
clang_disposeString(filename);
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = Val_int(line);
Store_field(data, 1, field);
}
{
CAMLlocal1(field);
field = Val_int(column);
Store_field(data, 2, field);
}
CAMLreturn(data);
}
}
CAMLprim value
clang_getInstantiationLocation_wrapper(value location_ocaml)
{
CAMLparam1(location_ocaml);
CXSourceLocation location;
location = Cxsourcelocation_val(Field(location_ocaml, 0));
CXFile file;
unsigned int line;
unsigned int column;
unsigned int offset;
clang_getInstantiationLocation(location, &file, &line, &column, &offset);
{
CAMLlocal1(data);
data = caml_alloc_tuple(4);
{
CAMLlocal1(field);
field = caml_alloc_tuple(1);
Store_field(field, 0, Val_cxfile(file));
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = Val_int(line);
Store_field(data, 1, field);
}
{
CAMLlocal1(field);
field = Val_int(column);
Store_field(data, 2, field);
}
{
CAMLlocal1(field);
field = Val_int(offset);
Store_field(data, 3, field);
}
CAMLreturn(data);
}
}
CAMLprim value
clang_getSpellingLocation_wrapper(value location_ocaml)
{
CAMLparam1(location_ocaml);
CXSourceLocation location;
location = Cxsourcelocation_val(Field(location_ocaml, 0));
CXFile file;
unsigned int line;
unsigned int column;
unsigned int offset;
clang_getSpellingLocation(location, &file, &line, &column, &offset);
{
CAMLlocal1(data);
data = caml_alloc_tuple(4);
{
CAMLlocal1(field);
field = caml_alloc_tuple(1);
Store_field(field, 0, Val_cxfile(file));
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = Val_int(line);
Store_field(data, 1, field);
}
{
CAMLlocal1(field);
field = Val_int(column);
Store_field(data, 2, field);
}
{
CAMLlocal1(field);
field = Val_int(offset);
Store_field(data, 3, field);
}
CAMLreturn(data);
}
}
CAMLprim value
clang_getFileLocation_wrapper(value location_ocaml)
{
CAMLparam1(location_ocaml);
CXSourceLocation location;
location = Cxsourcelocation_val(Field(location_ocaml, 0));
CXFile file;
unsigned int line;
unsigned int column;
unsigned int offset;
clang_getFileLocation(location, &file, &line, &column, &offset);
{
CAMLlocal1(data);
data = caml_alloc_tuple(4);
{
CAMLlocal1(field);
field = caml_alloc_tuple(1);
Store_field(field, 0, Val_cxfile(file));
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = Val_int(line);
Store_field(data, 1, field);
}
{
CAMLlocal1(field);
field = Val_int(column);
Store_field(data, 2, field);
}
{
CAMLlocal1(field);
field = Val_int(offset);
Store_field(data, 3, field);
}
CAMLreturn(data);
}
}
CAMLprim value
clang_getRangeStart_wrapper(value range_ocaml)
{
CAMLparam1(range_ocaml);
CXSourceRange range;
range = Cxsourcerange_val(Field(range_ocaml, 0));
CXSourceLocation result = clang_getRangeStart(range);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcelocation(result));
Store_field(data, 1, safe_field(range_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getRangeEnd_wrapper(value range_ocaml)
{
CAMLparam1(range_ocaml);
CXSourceRange range;
range = Cxsourcerange_val(Field(range_ocaml, 0));
CXSourceLocation result = clang_getRangeEnd(range);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcelocation(result));
Store_field(data, 1, safe_field(range_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getSkippedRanges_wrapper(value tu_ocaml, value file_ocaml)
{
CAMLparam2(tu_ocaml, file_ocaml);
CXTranslationUnit tu;
tu = Cxtranslationunit_val(Field(tu_ocaml, 0));
CXFile file;
file = Cxfile_val(Field(file_ocaml, 0));
CXSourceRangeList * result = clang_getSkippedRanges(tu, file);
{
CAMLlocal1(data);
data = caml_alloc(result->count, 0);
CAMLlocal1(field);
for (unsigned int i = 0; i < result->count; i++) {
field = caml_alloc_tuple(1);
Store_field(field, 0, Val_cxsourcerange(result->ranges[i]));
Store_field(data, i, field);
}
clang_disposeSourceRangeList(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getAllSkippedRanges_wrapper(value tu_ocaml)
{
CAMLparam1(tu_ocaml);
CXTranslationUnit tu;
tu = Cxtranslationunit_val(Field(tu_ocaml, 0));
CXSourceRangeList * result = clang_getAllSkippedRanges(tu);
{
CAMLlocal1(data);
data = caml_alloc(result->count, 0);
CAMLlocal1(field);
for (unsigned int i = 0; i < result->count; i++) {
field = caml_alloc_tuple(1);
Store_field(field, 0, Val_cxsourcerange(result->ranges[i]));
Store_field(data, i, field);
}
clang_disposeSourceRangeList(result);
CAMLreturn(data);
}
}
static void finalize_cxdiagnosticset(value v) {
clang_disposeDiagnosticSet(*((CXDiagnosticSet *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(CXDiagnosticSet, cxdiagnosticset, Cxdiagnosticset_val, Val_cxdiagnosticset, finalize_cxdiagnosticset, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getNumDiagnosticsInSet_wrapper(value Diags_ocaml)
{
CAMLparam1(Diags_ocaml);
CXDiagnosticSet Diags;
Diags = Cxdiagnosticset_val(Diags_ocaml);
unsigned int result = clang_getNumDiagnosticsInSet(Diags);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXDiagnostic, cxdiagnostic, Cxdiagnostic_val, Val_cxdiagnostic, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getDiagnosticInSet_wrapper(value Diags_ocaml, value Index_ocaml)
{
CAMLparam2(Diags_ocaml, Index_ocaml);
CXDiagnosticSet Diags;
Diags = Cxdiagnosticset_val(Diags_ocaml);
unsigned int Index;
Index = Int_val(Index_ocaml);
CXDiagnostic result = clang_getDiagnosticInSet(Diags, Index);
{
CAMLlocal1(data);
data = Val_cxdiagnostic(result);
CAMLreturn(data);
}
}
enum CXLoadDiag_Error
Cxloaddiag_error_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXLoadDiag_Unknown;
case 1: return CXLoadDiag_CannotLoad;
case 2: return CXLoadDiag_InvalidFile;
}
caml_failwith_fmt("invalid value for Cxloaddiag_error_val: %d", Int_val(ocaml));
return CXLoadDiag_Unknown;
}
value
Val_cxloaddiag_error(enum CXLoadDiag_Error v)
{
switch (v) {
case CXLoadDiag_Unknown: return Val_int(0);
case CXLoadDiag_CannotLoad: return Val_int(1);
case CXLoadDiag_InvalidFile: return Val_int(2);
case CXLoadDiag_None: caml_failwith("unexpected success value");
}
caml_failwith_fmt("invalid value for Val_cxloaddiag_error: %d", v);
return Val_int(0);
}
CAMLprim value
clang_loadDiagnostics_wrapper(value file_ocaml)
{
CAMLparam1(file_ocaml);
const char * file;
file = String_val(file_ocaml);
enum CXLoadDiag_Error error;
CXString errorString;
CXDiagnosticSet result = clang_loadDiagnostics(file, &error, &errorString);
if (error == CXLoadDiag_None) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_cxdiagnosticset(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = caml_alloc_tuple(2);
{
CAMLlocal1(field);
field = Val_cxloaddiag_error(error);
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = caml_copy_string(safe_string(clang_getCString(errorString)));
clang_disposeString(errorString);
Store_field(data, 1, field);
}
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_getChildDiagnostics_wrapper(value D_ocaml)
{
CAMLparam1(D_ocaml);
CXDiagnostic D;
D = Cxdiagnostic_val(D_ocaml);
CXDiagnosticSet result = clang_getChildDiagnostics(D);
{
CAMLlocal1(data);
data = Val_cxdiagnosticset(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getNumDiagnostics_wrapper(value Unit_ocaml)
{
CAMLparam1(Unit_ocaml);
CXTranslationUnit Unit;
Unit = Cxtranslationunit_val(Field(Unit_ocaml, 0));
unsigned int result = clang_getNumDiagnostics(Unit);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnostic_wrapper(value Unit_ocaml, value Index_ocaml)
{
CAMLparam2(Unit_ocaml, Index_ocaml);
CXTranslationUnit Unit;
Unit = Cxtranslationunit_val(Field(Unit_ocaml, 0));
unsigned int Index;
Index = Int_val(Index_ocaml);
CXDiagnostic result = clang_getDiagnostic(Unit, Index);
{
CAMLlocal1(data);
data = Val_cxdiagnostic(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticSetFromTU_wrapper(value Unit_ocaml)
{
CAMLparam1(Unit_ocaml);
CXTranslationUnit Unit;
Unit = Cxtranslationunit_val(Field(Unit_ocaml, 0));
CXDiagnosticSet result = clang_getDiagnosticSetFromTU(Unit);
{
CAMLlocal1(data);
data = Val_cxdiagnosticset(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_formatDiagnostic_wrapper(value Diagnostic_ocaml, value Options_ocaml)
{
CAMLparam2(Diagnostic_ocaml, Options_ocaml);
CXDiagnostic Diagnostic;
Diagnostic = Cxdiagnostic_val(Diagnostic_ocaml);
unsigned int Options;
Options = Int_val(Options_ocaml);
CXString result = clang_formatDiagnostic(Diagnostic, Options);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_defaultDiagnosticDisplayOptions_wrapper()
{
CAMLparam0();
unsigned int result = clang_defaultDiagnosticDisplayOptions();
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum CXDiagnosticSeverity
Cxdiagnosticseverity_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXDiagnostic_Ignored;
case 1: return CXDiagnostic_Note;
case 2: return CXDiagnostic_Warning;
case 3: return CXDiagnostic_Error;
case 4: return CXDiagnostic_Fatal;
}
caml_failwith_fmt("invalid value for Cxdiagnosticseverity_val: %d", Int_val(ocaml));
return CXDiagnostic_Ignored;
}
value
Val_cxdiagnosticseverity(enum CXDiagnosticSeverity v)
{
switch (v) {
case CXDiagnostic_Ignored: return Val_int(0);
case CXDiagnostic_Note: return Val_int(1);
case CXDiagnostic_Warning: return Val_int(2);
case CXDiagnostic_Error: return Val_int(3);
case CXDiagnostic_Fatal: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_cxdiagnosticseverity: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getDiagnosticSeverity_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXDiagnostic arg;
arg = Cxdiagnostic_val(arg_ocaml);
enum CXDiagnosticSeverity result = clang_getDiagnosticSeverity(arg);
{
CAMLlocal1(data);
data = Val_cxdiagnosticseverity(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticLocation_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXDiagnostic arg;
arg = Cxdiagnostic_val(arg_ocaml);
CXSourceLocation result = clang_getDiagnosticLocation(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxsourcelocation(result));
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticSpelling_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXDiagnostic arg;
arg = Cxdiagnostic_val(arg_ocaml);
CXString result = clang_getDiagnosticSpelling(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticOption_wrapper(value Diag_ocaml)
{
CAMLparam1(Diag_ocaml);
CXDiagnostic Diag;
Diag = Cxdiagnostic_val(Diag_ocaml);
CXString Disable;
CXString result = clang_getDiagnosticOption(Diag, &Disable);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
{
CAMLlocal1(field);
field = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = caml_copy_string(safe_string(clang_getCString(Disable)));
clang_disposeString(Disable);
Store_field(data, 1, field);
}
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticCategory_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXDiagnostic arg;
arg = Cxdiagnostic_val(arg_ocaml);
unsigned int result = clang_getDiagnosticCategory(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticCategoryText_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXDiagnostic arg;
arg = Cxdiagnostic_val(arg_ocaml);
CXString result = clang_getDiagnosticCategoryText(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticNumRanges_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXDiagnostic arg;
arg = Cxdiagnostic_val(arg_ocaml);
unsigned int result = clang_getDiagnosticNumRanges(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticRange_wrapper(value Diagnostic_ocaml, value Range_ocaml)
{
CAMLparam2(Diagnostic_ocaml, Range_ocaml);
CXDiagnostic Diagnostic;
Diagnostic = Cxdiagnostic_val(Diagnostic_ocaml);
unsigned int Range;
Range = Int_val(Range_ocaml);
CXSourceRange result = clang_getDiagnosticRange(Diagnostic, Range);
{
CAMLlocal1(data);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxsourcerange(result));
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticNumFixIts_wrapper(value Diagnostic_ocaml)
{
CAMLparam1(Diagnostic_ocaml);
CXDiagnostic Diagnostic;
Diagnostic = Cxdiagnostic_val(Diagnostic_ocaml);
unsigned int result = clang_getDiagnosticNumFixIts(Diagnostic);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getDiagnosticFixIt_wrapper(value Diagnostic_ocaml, value FixIt_ocaml, value ReplacementRange_ocaml)
{
CAMLparam3(Diagnostic_ocaml, FixIt_ocaml, ReplacementRange_ocaml);
CXDiagnostic Diagnostic;
Diagnostic = Cxdiagnostic_val(Diagnostic_ocaml);
unsigned int FixIt;
FixIt = Int_val(FixIt_ocaml);
CXSourceRange ReplacementRange;
ReplacementRange = Cxsourcerange_val(Field(ReplacementRange_ocaml, 0));
CXString result = clang_getDiagnosticFixIt(Diagnostic, FixIt, &ReplacementRange);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
{
CAMLlocal1(field);
field = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = caml_alloc_tuple(1);
Store_field(field, 0, Val_cxsourcerange(ReplacementRange));
Store_field(data, 1, field);
}
CAMLreturn(data);
}
}
CAMLprim value
clang_getTranslationUnitSpelling_wrapper(value CTUnit_ocaml)
{
CAMLparam1(CTUnit_ocaml);
CXTranslationUnit CTUnit;
CTUnit = Cxtranslationunit_val(Field(CTUnit_ocaml, 0));
CXString result = clang_getTranslationUnitSpelling(CTUnit);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
static value __attribute__((unused))
Val_cxunsavedfile(struct CXUnsavedFile v)
{
CAMLparam0();
CAMLlocal1(ocaml);
ocaml = caml_alloc_tuple(2);
{
CAMLlocal1(data);
data = caml_copy_string(v.Filename);
Store_field(ocaml, 0, data);
}
{
CAMLlocal1(data);
data = caml_alloc_initialized_string(v.Length, v.Contents);
Store_field(ocaml, 1, data);
}
CAMLreturn(ocaml);
}
static struct CXUnsavedFile __attribute__((unused))
Cxunsavedfile_val(value ocaml)
{
CAMLparam1(ocaml);
struct CXUnsavedFile v;
v.Filename = String_val(Field(ocaml, 0));v.Length = caml_string_length(Field(ocaml, 1));
v.Contents = String_val(Field(ocaml, 1));
CAMLreturnT(struct CXUnsavedFile, v);
}
CAMLprim value
clang_createTranslationUnitFromSourceFile_wrapper(value CIdx_ocaml, value source_filename_ocaml, value clang_command_line_args_ocaml, value unsaved_files_ocaml)
{
CAMLparam4(CIdx_ocaml, source_filename_ocaml, clang_command_line_args_ocaml, unsaved_files_ocaml);
CXIndex CIdx;
CIdx = Cxindex_val(CIdx_ocaml);
const char * source_filename;
source_filename = String_val(source_filename_ocaml);
int num_clang_command_line_args = Wosize_val(clang_command_line_args_ocaml);
char const ** clang_command_line_args = xmalloc(num_clang_command_line_args * sizeof(const char *const));
int i; for (i = 0; i < num_clang_command_line_args; i++) {
clang_command_line_args[i] = String_val(Field(clang_command_line_args_ocaml, i));
}
unsigned int num_unsaved_files = Wosize_val(unsaved_files_ocaml);
struct CXUnsavedFile * unsaved_files = xmalloc(num_unsaved_files * sizeof(struct CXUnsavedFile));
unsigned int i2; for (i2 = 0; i2 < num_unsaved_files; i2++) {
unsaved_files[i2] = Cxunsavedfile_val(Field(unsaved_files_ocaml, i2));
}
CXTranslationUnit result = clang_createTranslationUnitFromSourceFile(CIdx, source_filename, num_clang_command_line_args, clang_command_line_args, num_unsaved_files, unsaved_files);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtranslationunit(result));
Store_field(data, 1, CIdx_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_createTranslationUnit_wrapper(value CIdx_ocaml, value ast_filename_ocaml)
{
CAMLparam2(CIdx_ocaml, ast_filename_ocaml);
CXIndex CIdx;
CIdx = Cxindex_val(CIdx_ocaml);
const char * ast_filename;
ast_filename = String_val(ast_filename_ocaml);
CXTranslationUnit result = clang_createTranslationUnit(CIdx, ast_filename);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtranslationunit(result));
Store_field(data, 1, CIdx_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_createTranslationUnit2_wrapper(value CIdx_ocaml, value ast_filename_ocaml)
{
CAMLparam2(CIdx_ocaml, ast_filename_ocaml);
CXIndex CIdx;
CIdx = Cxindex_val(CIdx_ocaml);
const char * ast_filename;
ast_filename = String_val(ast_filename_ocaml);
CXTranslationUnit out_TU;
enum CXErrorCode result = clang_createTranslationUnit2(CIdx, ast_filename, &out_TU);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxtranslationunit(out_TU));
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_defaultEditingTranslationUnitOptions_wrapper()
{
CAMLparam0();
unsigned int result = clang_defaultEditingTranslationUnitOptions();
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_parseTranslationUnit_wrapper(value CIdx_ocaml, value source_filename_ocaml, value command_line_args_ocaml, value unsaved_files_ocaml, value options_ocaml)
{
CAMLparam5(CIdx_ocaml, source_filename_ocaml, command_line_args_ocaml, unsaved_files_ocaml, options_ocaml);
CXIndex CIdx;
CIdx = Cxindex_val(CIdx_ocaml);
const char * source_filename;
source_filename = String_val(source_filename_ocaml);
int num_command_line_args = Wosize_val(command_line_args_ocaml);
char const ** command_line_args = xmalloc(num_command_line_args * sizeof(const char *const));
int i; for (i = 0; i < num_command_line_args; i++) {
command_line_args[i] = String_val(Field(command_line_args_ocaml, i));
}
unsigned int num_unsaved_files = Wosize_val(unsaved_files_ocaml);
struct CXUnsavedFile * unsaved_files = xmalloc(num_unsaved_files * sizeof(struct CXUnsavedFile));
unsigned int i2; for (i2 = 0; i2 < num_unsaved_files; i2++) {
unsaved_files[i2] = Cxunsavedfile_val(Field(unsaved_files_ocaml, i2));
}
unsigned int options;
options = Int_val(options_ocaml);
CXTranslationUnit result = clang_parseTranslationUnit(CIdx, source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, options);
{
CAMLlocal1(data);
if (result == NULL) {
data = Val_int(0);
}
else {
CAMLlocal1(option_value);
option_value = caml_alloc_tuple(2);
Store_field(option_value, 0, Val_cxtranslationunit(result));
Store_field(option_value, 1, CIdx_ocaml);
data = caml_alloc(1, 0);
Store_field(data, 0, option_value);
};
CAMLreturn(data);
}
}
CAMLprim value
clang_parseTranslationUnit2_wrapper(value CIdx_ocaml, value source_filename_ocaml, value command_line_args_ocaml, value unsaved_files_ocaml, value options_ocaml)
{
CAMLparam5(CIdx_ocaml, source_filename_ocaml, command_line_args_ocaml, unsaved_files_ocaml, options_ocaml);
CXIndex CIdx;
CIdx = Cxindex_val(CIdx_ocaml);
const char * source_filename;
source_filename = String_val(source_filename_ocaml);
int num_command_line_args = Wosize_val(command_line_args_ocaml);
char const ** command_line_args = xmalloc(num_command_line_args * sizeof(const char *const));
int i; for (i = 0; i < num_command_line_args; i++) {
command_line_args[i] = String_val(Field(command_line_args_ocaml, i));
}
unsigned int num_unsaved_files = Wosize_val(unsaved_files_ocaml);
struct CXUnsavedFile * unsaved_files = xmalloc(num_unsaved_files * sizeof(struct CXUnsavedFile));
unsigned int i2; for (i2 = 0; i2 < num_unsaved_files; i2++) {
unsaved_files[i2] = Cxunsavedfile_val(Field(unsaved_files_ocaml, i2));
}
unsigned int options;
options = Int_val(options_ocaml);
CXTranslationUnit out_TU;
enum CXErrorCode result = clang_parseTranslationUnit2(CIdx, source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, options, &out_TU);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxtranslationunit(out_TU));
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_parseTranslationUnit2FullArgv_wrapper(value CIdx_ocaml, value source_filename_ocaml, value command_line_args_ocaml, value unsaved_files_ocaml, value options_ocaml)
{
CAMLparam5(CIdx_ocaml, source_filename_ocaml, command_line_args_ocaml, unsaved_files_ocaml, options_ocaml);
CXIndex CIdx;
CIdx = Cxindex_val(CIdx_ocaml);
const char * source_filename;
source_filename = String_val(source_filename_ocaml);
int num_command_line_args = Wosize_val(command_line_args_ocaml);
char const ** command_line_args = xmalloc(num_command_line_args * sizeof(const char *const));
int i; for (i = 0; i < num_command_line_args; i++) {
command_line_args[i] = String_val(Field(command_line_args_ocaml, i));
}
unsigned int num_unsaved_files = Wosize_val(unsaved_files_ocaml);
struct CXUnsavedFile * unsaved_files = xmalloc(num_unsaved_files * sizeof(struct CXUnsavedFile));
unsigned int i2; for (i2 = 0; i2 < num_unsaved_files; i2++) {
unsaved_files[i2] = Cxunsavedfile_val(Field(unsaved_files_ocaml, i2));
}
unsigned int options;
options = Int_val(options_ocaml);
CXTranslationUnit out_TU;
enum CXErrorCode result = clang_parseTranslationUnit2FullArgv(CIdx, source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, options, &out_TU);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxtranslationunit(out_TU));
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_defaultSaveOptions_wrapper(value TU_ocaml)
{
CAMLparam1(TU_ocaml);
CXTranslationUnit TU;
TU = Cxtranslationunit_val(Field(TU_ocaml, 0));
unsigned int result = clang_defaultSaveOptions(TU);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum CXSaveError
Cxsaveerror_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXSaveError_Unknown;
case 1: return CXSaveError_TranslationErrors;
case 2: return CXSaveError_InvalidTU;
}
caml_failwith_fmt("invalid value for Cxsaveerror_val: %d", Int_val(ocaml));
return CXSaveError_Unknown;
}
value
Val_cxsaveerror(enum CXSaveError v)
{
switch (v) {
case CXSaveError_Unknown: return Val_int(0);
case CXSaveError_TranslationErrors: return Val_int(1);
case CXSaveError_InvalidTU: return Val_int(2);
case CXSaveError_None: caml_failwith("unexpected success value");
}
caml_failwith_fmt("invalid value for Val_cxsaveerror: %d", v);
return Val_int(0);
}
CAMLprim value
clang_saveTranslationUnit_wrapper(value TU_ocaml, value FileName_ocaml, value options_ocaml)
{
CAMLparam3(TU_ocaml, FileName_ocaml, options_ocaml);
CXTranslationUnit TU;
TU = Cxtranslationunit_val(Field(TU_ocaml, 0));
const char * FileName;
FileName = String_val(FileName_ocaml);
unsigned int options;
options = Int_val(options_ocaml);
int result = clang_saveTranslationUnit(TU, FileName, options);
if (result == CXSaveError_None) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_unit;
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxsaveerror(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
CAMLprim value
clang_suspendTranslationUnit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
unsigned int result = clang_suspendTranslationUnit(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_defaultReparseOptions_wrapper(value TU_ocaml)
{
CAMLparam1(TU_ocaml);
CXTranslationUnit TU;
TU = Cxtranslationunit_val(Field(TU_ocaml, 0));
unsigned int result = clang_defaultReparseOptions(TU);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_reparseTranslationUnit_wrapper(value TU_ocaml, value unsaved_files_ocaml, value options_ocaml)
{
CAMLparam3(TU_ocaml, unsaved_files_ocaml, options_ocaml);
CXTranslationUnit TU;
TU = Cxtranslationunit_val(Field(TU_ocaml, 0));
unsigned int num_unsaved_files = Wosize_val(unsaved_files_ocaml);
struct CXUnsavedFile * unsaved_files = xmalloc(num_unsaved_files * sizeof(struct CXUnsavedFile));
unsigned int i; for (i = 0; i < num_unsaved_files; i++) {
unsaved_files[i] = Cxunsavedfile_val(Field(unsaved_files_ocaml, i));
}
unsigned int options;
options = Int_val(options_ocaml);
int result = clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files, options);
if (result == CXError_Success) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = Val_unit;
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 1);
data = Val_cxerrorcode(result);
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}}
enum CXTUResourceUsageKind
Cxturesourceusagekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXTUResourceUsage_AST;
case 1: return CXTUResourceUsage_Identifiers;
case 2: return CXTUResourceUsage_Selectors;
case 3: return CXTUResourceUsage_GlobalCompletionResults;
case 4: return CXTUResourceUsage_SourceManagerContentCache;
case 5: return CXTUResourceUsage_AST_SideTables;
case 6: return CXTUResourceUsage_SourceManager_Membuffer_Malloc;
case 7: return CXTUResourceUsage_SourceManager_Membuffer_MMap;
case 8: return CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc;
case 9: return CXTUResourceUsage_ExternalASTSource_Membuffer_MMap;
case 10: return CXTUResourceUsage_Preprocessor;
case 11: return CXTUResourceUsage_PreprocessingRecord;
case 12: return CXTUResourceUsage_SourceManager_DataStructures;
case 13: return CXTUResourceUsage_Preprocessor_HeaderSearch;
}
caml_failwith_fmt("invalid value for Cxturesourceusagekind_val: %d", Int_val(ocaml));
return CXTUResourceUsage_AST;
}
value
Val_cxturesourceusagekind(enum CXTUResourceUsageKind v)
{
switch (v) {
case CXTUResourceUsage_AST: return Val_int(0);
case CXTUResourceUsage_Identifiers: return Val_int(1);
case CXTUResourceUsage_Selectors: return Val_int(2);
case CXTUResourceUsage_GlobalCompletionResults: return Val_int(3);
case CXTUResourceUsage_SourceManagerContentCache: return Val_int(4);
case CXTUResourceUsage_AST_SideTables: return Val_int(5);
case CXTUResourceUsage_SourceManager_Membuffer_Malloc: return Val_int(6);
case CXTUResourceUsage_SourceManager_Membuffer_MMap: return Val_int(7);
case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: return Val_int(8);
case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: return Val_int(9);
case CXTUResourceUsage_Preprocessor: return Val_int(10);
case CXTUResourceUsage_PreprocessingRecord: return Val_int(11);
case CXTUResourceUsage_SourceManager_DataStructures: return Val_int(12);
case CXTUResourceUsage_Preprocessor_HeaderSearch: return Val_int(13);
}
caml_failwith_fmt("invalid value for Val_cxturesourceusagekind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getTUResourceUsageName_wrapper(value kind_ocaml)
{
CAMLparam1(kind_ocaml);
enum CXTUResourceUsageKind kind;
kind = Cxturesourceusagekind_val(kind_ocaml);
const char * result = clang_getTUResourceUsageName(kind);
{
CAMLlocal1(data);
data = caml_copy_string(result);
CAMLreturn(data);
}
}
static void finalize_cxturesourceusage(value v) {
clang_disposeCXTUResourceUsage(*((struct CXTUResourceUsage *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct CXTUResourceUsage, cxturesourceusage, Cxturesourceusage_val, Val_cxturesourceusage, finalize_cxturesourceusage, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getCXTUResourceUsage_wrapper(value TU_ocaml)
{
CAMLparam1(TU_ocaml);
CXTranslationUnit TU;
TU = Cxtranslationunit_val(Field(TU_ocaml, 0));
CXTUResourceUsage result = clang_getCXTUResourceUsage(TU);
{
CAMLlocal1(data);
data = Val_cxturesourceusage(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXTargetInfo, cxtargetinfo, Cxtargetinfo_val, Val_cxtargetinfo, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getTranslationUnitTargetInfo_wrapper(value CTUnit_ocaml)
{
CAMLparam1(CTUnit_ocaml);
CXTranslationUnit CTUnit;
CTUnit = Cxtranslationunit_val(Field(CTUnit_ocaml, 0));
CXTargetInfo result = clang_getTranslationUnitTargetInfo(CTUnit);
{
CAMLlocal1(data);
data = Val_cxtargetinfo(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_TargetInfo_getTriple_wrapper(value Info_ocaml)
{
CAMLparam1(Info_ocaml);
CXTargetInfo Info;
Info = Cxtargetinfo_val(Info_ocaml);
CXString result = clang_TargetInfo_getTriple(Info);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_TargetInfo_getPointerWidth_wrapper(value Info_ocaml)
{
CAMLparam1(Info_ocaml);
CXTargetInfo Info;
Info = Cxtargetinfo_val(Info_ocaml);
int result = clang_TargetInfo_getPointerWidth(Info);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum CXCursorKind
Cxcursorkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXCursor_UnexposedDecl;
case 1: return CXCursor_StructDecl;
case 2: return CXCursor_UnionDecl;
case 3: return CXCursor_ClassDecl;
case 4: return CXCursor_EnumDecl;
case 5: return CXCursor_FieldDecl;
case 6: return CXCursor_EnumConstantDecl;
case 7: return CXCursor_FunctionDecl;
case 8: return CXCursor_VarDecl;
case 9: return CXCursor_ParmDecl;
case 10: return CXCursor_ObjCInterfaceDecl;
case 11: return CXCursor_ObjCCategoryDecl;
case 12: return CXCursor_ObjCProtocolDecl;
case 13: return CXCursor_ObjCPropertyDecl;
case 14: return CXCursor_ObjCIvarDecl;
case 15: return CXCursor_ObjCInstanceMethodDecl;
case 16: return CXCursor_ObjCClassMethodDecl;
case 17: return CXCursor_ObjCImplementationDecl;
case 18: return CXCursor_ObjCCategoryImplDecl;
case 19: return CXCursor_TypedefDecl;
case 20: return CXCursor_CXXMethod;
case 21: return CXCursor_Namespace;
case 22: return CXCursor_LinkageSpec;
case 23: return CXCursor_Constructor;
case 24: return CXCursor_Destructor;
case 25: return CXCursor_ConversionFunction;
case 26: return CXCursor_TemplateTypeParameter;
case 27: return CXCursor_NonTypeTemplateParameter;
case 28: return CXCursor_TemplateTemplateParameter;
case 29: return CXCursor_FunctionTemplate;
case 30: return CXCursor_ClassTemplate;
case 31: return CXCursor_ClassTemplatePartialSpecialization;
case 32: return CXCursor_NamespaceAlias;
case 33: return CXCursor_UsingDirective;
case 34: return CXCursor_UsingDeclaration;
case 35: return CXCursor_TypeAliasDecl;
case 36: return CXCursor_ObjCSynthesizeDecl;
case 37: return CXCursor_ObjCDynamicDecl;
case 38: return CXCursor_CXXAccessSpecifier;
case 39: return CXCursor_ObjCSuperClassRef;
case 40: return CXCursor_ObjCProtocolRef;
case 41: return CXCursor_ObjCClassRef;
case 42: return CXCursor_TypeRef;
case 43: return CXCursor_CXXBaseSpecifier;
case 44: return CXCursor_TemplateRef;
case 45: return CXCursor_NamespaceRef;
case 46: return CXCursor_MemberRef;
case 47: return CXCursor_LabelRef;
case 48: return CXCursor_OverloadedDeclRef;
case 49: return CXCursor_VariableRef;
case 50: return CXCursor_InvalidFile;
case 51: return CXCursor_NoDeclFound;
case 52: return CXCursor_NotImplemented;
case 53: return CXCursor_InvalidCode;
case 54: return CXCursor_UnexposedExpr;
case 55: return CXCursor_DeclRefExpr;
case 56: return CXCursor_MemberRefExpr;
case 57: return CXCursor_CallExpr;
case 58: return CXCursor_ObjCMessageExpr;
case 59: return CXCursor_BlockExpr;
case 60: return CXCursor_IntegerLiteral;
case 61: return CXCursor_FloatingLiteral;
case 62: return CXCursor_ImaginaryLiteral;
case 63: return CXCursor_StringLiteral;
case 64: return CXCursor_CharacterLiteral;
case 65: return CXCursor_ParenExpr;
case 66: return CXCursor_UnaryOperator;
case 67: return CXCursor_ArraySubscriptExpr;
case 68: return CXCursor_BinaryOperator;
case 69: return CXCursor_CompoundAssignOperator;
case 70: return CXCursor_ConditionalOperator;
case 71: return CXCursor_CStyleCastExpr;
case 72: return CXCursor_CompoundLiteralExpr;
case 73: return CXCursor_InitListExpr;
case 74: return CXCursor_AddrLabelExpr;
case 75: return CXCursor_StmtExpr;
case 76: return CXCursor_GenericSelectionExpr;
case 77: return CXCursor_GNUNullExpr;
case 78: return CXCursor_CXXStaticCastExpr;
case 79: return CXCursor_CXXDynamicCastExpr;
case 80: return CXCursor_CXXReinterpretCastExpr;
case 81: return CXCursor_CXXConstCastExpr;
case 82: return CXCursor_CXXFunctionalCastExpr;
case 83: return CXCursor_CXXAddrspaceCastExpr;
case 84: return CXCursor_CXXTypeidExpr;
case 85: return CXCursor_CXXBoolLiteralExpr;
case 86: return CXCursor_CXXNullPtrLiteralExpr;
case 87: return CXCursor_CXXThisExpr;
case 88: return CXCursor_CXXThrowExpr;
case 89: return CXCursor_CXXNewExpr;
case 90: return CXCursor_CXXDeleteExpr;
case 91: return CXCursor_UnaryExpr;
case 92: return CXCursor_ObjCStringLiteral;
case 93: return CXCursor_ObjCEncodeExpr;
case 94: return CXCursor_ObjCSelectorExpr;
case 95: return CXCursor_ObjCProtocolExpr;
case 96: return CXCursor_ObjCBridgedCastExpr;
case 97: return CXCursor_PackExpansionExpr;
case 98: return CXCursor_SizeOfPackExpr;
case 99: return CXCursor_LambdaExpr;
case 100: return CXCursor_ObjCBoolLiteralExpr;
case 101: return CXCursor_ObjCSelfExpr;
case 102: return CXCursor_OMPArraySectionExpr;
case 103: return CXCursor_ObjCAvailabilityCheckExpr;
case 104: return CXCursor_FixedPointLiteral;
case 105: return CXCursor_OMPArrayShapingExpr;
case 106: return CXCursor_OMPIteratorExpr;
case 107: return CXCursor_UnexposedStmt;
case 108: return CXCursor_LabelStmt;
case 109: return CXCursor_CompoundStmt;
case 110: return CXCursor_CaseStmt;
case 111: return CXCursor_DefaultStmt;
case 112: return CXCursor_IfStmt;
case 113: return CXCursor_SwitchStmt;
case 114: return CXCursor_WhileStmt;
case 115: return CXCursor_DoStmt;
case 116: return CXCursor_ForStmt;
case 117: return CXCursor_GotoStmt;
case 118: return CXCursor_IndirectGotoStmt;
case 119: return CXCursor_ContinueStmt;
case 120: return CXCursor_BreakStmt;
case 121: return CXCursor_ReturnStmt;
case 122: return CXCursor_GCCAsmStmt;
case 123: return CXCursor_ObjCAtTryStmt;
case 124: return CXCursor_ObjCAtCatchStmt;
case 125: return CXCursor_ObjCAtFinallyStmt;
case 126: return CXCursor_ObjCAtThrowStmt;
case 127: return CXCursor_ObjCAtSynchronizedStmt;
case 128: return CXCursor_ObjCAutoreleasePoolStmt;
case 129: return CXCursor_ObjCForCollectionStmt;
case 130: return CXCursor_CXXCatchStmt;
case 131: return CXCursor_CXXTryStmt;
case 132: return CXCursor_CXXForRangeStmt;
case 133: return CXCursor_SEHTryStmt;
case 134: return CXCursor_SEHExceptStmt;
case 135: return CXCursor_SEHFinallyStmt;
case 136: return CXCursor_MSAsmStmt;
case 137: return CXCursor_NullStmt;
case 138: return CXCursor_DeclStmt;
case 139: return CXCursor_OMPParallelDirective;
case 140: return CXCursor_OMPSimdDirective;
case 141: return CXCursor_OMPForDirective;
case 142: return CXCursor_OMPSectionsDirective;
case 143: return CXCursor_OMPSectionDirective;
case 144: return CXCursor_OMPSingleDirective;
case 145: return CXCursor_OMPParallelForDirective;
case 146: return CXCursor_OMPParallelSectionsDirective;
case 147: return CXCursor_OMPTaskDirective;
case 148: return CXCursor_OMPMasterDirective;
case 149: return CXCursor_OMPCriticalDirective;
case 150: return CXCursor_OMPTaskyieldDirective;
case 151: return CXCursor_OMPBarrierDirective;
case 152: return CXCursor_OMPTaskwaitDirective;
case 153: return CXCursor_OMPFlushDirective;
case 154: return CXCursor_SEHLeaveStmt;
case 155: return CXCursor_OMPOrderedDirective;
case 156: return CXCursor_OMPAtomicDirective;
case 157: return CXCursor_OMPForSimdDirective;
case 158: return CXCursor_OMPParallelForSimdDirective;
case 159: return CXCursor_OMPTargetDirective;
case 160: return CXCursor_OMPTeamsDirective;
case 161: return CXCursor_OMPTaskgroupDirective;
case 162: return CXCursor_OMPCancellationPointDirective;
case 163: return CXCursor_OMPCancelDirective;
case 164: return CXCursor_OMPTargetDataDirective;
case 165: return CXCursor_OMPTaskLoopDirective;
case 166: return CXCursor_OMPTaskLoopSimdDirective;
case 167: return CXCursor_OMPDistributeDirective;
case 168: return CXCursor_OMPTargetEnterDataDirective;
case 169: return CXCursor_OMPTargetExitDataDirective;
case 170: return CXCursor_OMPTargetParallelDirective;
case 171: return CXCursor_OMPTargetParallelForDirective;
case 172: return CXCursor_OMPTargetUpdateDirective;
case 173: return CXCursor_OMPDistributeParallelForDirective;
case 174: return CXCursor_OMPDistributeParallelForSimdDirective;
case 175: return CXCursor_OMPDistributeSimdDirective;
case 176: return CXCursor_OMPTargetParallelForSimdDirective;
case 177: return CXCursor_OMPTargetSimdDirective;
case 178: return CXCursor_OMPTeamsDistributeDirective;
case 179: return CXCursor_OMPTeamsDistributeSimdDirective;
case 180: return CXCursor_OMPTeamsDistributeParallelForSimdDirective;
case 181: return CXCursor_OMPTeamsDistributeParallelForDirective;
case 182: return CXCursor_OMPTargetTeamsDirective;
case 183: return CXCursor_OMPTargetTeamsDistributeDirective;
case 184: return CXCursor_OMPTargetTeamsDistributeParallelForDirective;
case 185: return CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective;
case 186: return CXCursor_OMPTargetTeamsDistributeSimdDirective;
case 187: return CXCursor_BuiltinBitCastExpr;
case 188: return CXCursor_OMPMasterTaskLoopDirective;
case 189: return CXCursor_OMPParallelMasterTaskLoopDirective;
case 190: return CXCursor_OMPMasterTaskLoopSimdDirective;
case 191: return CXCursor_OMPParallelMasterTaskLoopSimdDirective;
case 192: return CXCursor_OMPParallelMasterDirective;
case 193: return CXCursor_OMPDepobjDirective;
case 194: return CXCursor_OMPScanDirective;
case 195: return CXCursor_TranslationUnit;
case 196: return CXCursor_UnexposedAttr;
case 197: return CXCursor_IBActionAttr;
case 198: return CXCursor_IBOutletAttr;
case 199: return CXCursor_IBOutletCollectionAttr;
case 200: return CXCursor_CXXFinalAttr;
case 201: return CXCursor_CXXOverrideAttr;
case 202: return CXCursor_AnnotateAttr;
case 203: return CXCursor_AsmLabelAttr;
case 204: return CXCursor_PackedAttr;
case 205: return CXCursor_PureAttr;
case 206: return CXCursor_ConstAttr;
case 207: return CXCursor_NoDuplicateAttr;
case 208: return CXCursor_CUDAConstantAttr;
case 209: return CXCursor_CUDADeviceAttr;
case 210: return CXCursor_CUDAGlobalAttr;
case 211: return CXCursor_CUDAHostAttr;
case 212: return CXCursor_CUDASharedAttr;
case 213: return CXCursor_VisibilityAttr;
case 214: return CXCursor_DLLExport;
case 215: return CXCursor_DLLImport;
case 216: return CXCursor_NSReturnsRetained;
case 217: return CXCursor_NSReturnsNotRetained;
case 218: return CXCursor_NSReturnsAutoreleased;
case 219: return CXCursor_NSConsumesSelf;
case 220: return CXCursor_NSConsumed;
case 221: return CXCursor_ObjCException;
case 222: return CXCursor_ObjCNSObject;
case 223: return CXCursor_ObjCIndependentClass;
case 224: return CXCursor_ObjCPreciseLifetime;
case 225: return CXCursor_ObjCReturnsInnerPointer;
case 226: return CXCursor_ObjCRequiresSuper;
case 227: return CXCursor_ObjCRootClass;
case 228: return CXCursor_ObjCSubclassingRestricted;
case 229: return CXCursor_ObjCExplicitProtocolImpl;
case 230: return CXCursor_ObjCDesignatedInitializer;
case 231: return CXCursor_ObjCRuntimeVisible;
case 232: return CXCursor_ObjCBoxable;
case 233: return CXCursor_FlagEnum;
case 234: return CXCursor_ConvergentAttr;
case 235: return CXCursor_WarnUnusedAttr;
case 236: return CXCursor_WarnUnusedResultAttr;
case 237: return CXCursor_AlignedAttr;
case 238: return CXCursor_PreprocessingDirective;
case 239: return CXCursor_MacroDefinition;
case 240: return CXCursor_MacroExpansion;
case 241: return CXCursor_InclusionDirective;
case 242: return CXCursor_ModuleImportDecl;
case 243: return CXCursor_TypeAliasTemplateDecl;
case 244: return CXCursor_StaticAssert;
case 245: return CXCursor_FriendDecl;
case 246: return CXCursor_OverloadCandidate;
}
caml_failwith_fmt("invalid value for Cxcursorkind_val: %d", Int_val(ocaml));
return CXCursor_UnexposedDecl;
}
value
Val_cxcursorkind(enum CXCursorKind v)
{
switch (v) {
case CXCursor_UnexposedDecl: return Val_int(0);
case CXCursor_StructDecl: return Val_int(1);
case CXCursor_UnionDecl: return Val_int(2);
case CXCursor_ClassDecl: return Val_int(3);
case CXCursor_EnumDecl: return Val_int(4);
case CXCursor_FieldDecl: return Val_int(5);
case CXCursor_EnumConstantDecl: return Val_int(6);
case CXCursor_FunctionDecl: return Val_int(7);
case CXCursor_VarDecl: return Val_int(8);
case CXCursor_ParmDecl: return Val_int(9);
case CXCursor_ObjCInterfaceDecl: return Val_int(10);
case CXCursor_ObjCCategoryDecl: return Val_int(11);
case CXCursor_ObjCProtocolDecl: return Val_int(12);
case CXCursor_ObjCPropertyDecl: return Val_int(13);
case CXCursor_ObjCIvarDecl: return Val_int(14);
case CXCursor_ObjCInstanceMethodDecl: return Val_int(15);
case CXCursor_ObjCClassMethodDecl: return Val_int(16);
case CXCursor_ObjCImplementationDecl: return Val_int(17);
case CXCursor_ObjCCategoryImplDecl: return Val_int(18);
case CXCursor_TypedefDecl: return Val_int(19);
case CXCursor_CXXMethod: return Val_int(20);
case CXCursor_Namespace: return Val_int(21);
case CXCursor_LinkageSpec: return Val_int(22);
case CXCursor_Constructor: return Val_int(23);
case CXCursor_Destructor: return Val_int(24);
case CXCursor_ConversionFunction: return Val_int(25);
case CXCursor_TemplateTypeParameter: return Val_int(26);
case CXCursor_NonTypeTemplateParameter: return Val_int(27);
case CXCursor_TemplateTemplateParameter: return Val_int(28);
case CXCursor_FunctionTemplate: return Val_int(29);
case CXCursor_ClassTemplate: return Val_int(30);
case CXCursor_ClassTemplatePartialSpecialization: return Val_int(31);
case CXCursor_NamespaceAlias: return Val_int(32);
case CXCursor_UsingDirective: return Val_int(33);
case CXCursor_UsingDeclaration: return Val_int(34);
case CXCursor_TypeAliasDecl: return Val_int(35);
case CXCursor_ObjCSynthesizeDecl: return Val_int(36);
case CXCursor_ObjCDynamicDecl: return Val_int(37);
case CXCursor_CXXAccessSpecifier: return Val_int(38);
case CXCursor_ObjCSuperClassRef: return Val_int(39);
case CXCursor_ObjCProtocolRef: return Val_int(40);
case CXCursor_ObjCClassRef: return Val_int(41);
case CXCursor_TypeRef: return Val_int(42);
case CXCursor_CXXBaseSpecifier: return Val_int(43);
case CXCursor_TemplateRef: return Val_int(44);
case CXCursor_NamespaceRef: return Val_int(45);
case CXCursor_MemberRef: return Val_int(46);
case CXCursor_LabelRef: return Val_int(47);
case CXCursor_OverloadedDeclRef: return Val_int(48);
case CXCursor_VariableRef: return Val_int(49);
case CXCursor_InvalidFile: return Val_int(50);
case CXCursor_NoDeclFound: return Val_int(51);
case CXCursor_NotImplemented: return Val_int(52);
case CXCursor_InvalidCode: return Val_int(53);
case CXCursor_UnexposedExpr: return Val_int(54);
case CXCursor_DeclRefExpr: return Val_int(55);
case CXCursor_MemberRefExpr: return Val_int(56);
case CXCursor_CallExpr: return Val_int(57);
case CXCursor_ObjCMessageExpr: return Val_int(58);
case CXCursor_BlockExpr: return Val_int(59);
case CXCursor_IntegerLiteral: return Val_int(60);
case CXCursor_FloatingLiteral: return Val_int(61);
case CXCursor_ImaginaryLiteral: return Val_int(62);
case CXCursor_StringLiteral: return Val_int(63);
case CXCursor_CharacterLiteral: return Val_int(64);
case CXCursor_ParenExpr: return Val_int(65);
case CXCursor_UnaryOperator: return Val_int(66);
case CXCursor_ArraySubscriptExpr: return Val_int(67);
case CXCursor_BinaryOperator: return Val_int(68);
case CXCursor_CompoundAssignOperator: return Val_int(69);
case CXCursor_ConditionalOperator: return Val_int(70);
case CXCursor_CStyleCastExpr: return Val_int(71);
case CXCursor_CompoundLiteralExpr: return Val_int(72);
case CXCursor_InitListExpr: return Val_int(73);
case CXCursor_AddrLabelExpr: return Val_int(74);
case CXCursor_StmtExpr: return Val_int(75);
case CXCursor_GenericSelectionExpr: return Val_int(76);
case CXCursor_GNUNullExpr: return Val_int(77);
case CXCursor_CXXStaticCastExpr: return Val_int(78);
case CXCursor_CXXDynamicCastExpr: return Val_int(79);
case CXCursor_CXXReinterpretCastExpr: return Val_int(80);
case CXCursor_CXXConstCastExpr: return Val_int(81);
case CXCursor_CXXFunctionalCastExpr: return Val_int(82);
case CXCursor_CXXAddrspaceCastExpr: return Val_int(83);
case CXCursor_CXXTypeidExpr: return Val_int(84);
case CXCursor_CXXBoolLiteralExpr: return Val_int(85);
case CXCursor_CXXNullPtrLiteralExpr: return Val_int(86);
case CXCursor_CXXThisExpr: return Val_int(87);
case CXCursor_CXXThrowExpr: return Val_int(88);
case CXCursor_CXXNewExpr: return Val_int(89);
case CXCursor_CXXDeleteExpr: return Val_int(90);
case CXCursor_UnaryExpr: return Val_int(91);
case CXCursor_ObjCStringLiteral: return Val_int(92);
case CXCursor_ObjCEncodeExpr: return Val_int(93);
case CXCursor_ObjCSelectorExpr: return Val_int(94);
case CXCursor_ObjCProtocolExpr: return Val_int(95);
case CXCursor_ObjCBridgedCastExpr: return Val_int(96);
case CXCursor_PackExpansionExpr: return Val_int(97);
case CXCursor_SizeOfPackExpr: return Val_int(98);
case CXCursor_LambdaExpr: return Val_int(99);
case CXCursor_ObjCBoolLiteralExpr: return Val_int(100);
case CXCursor_ObjCSelfExpr: return Val_int(101);
case CXCursor_OMPArraySectionExpr: return Val_int(102);
case CXCursor_ObjCAvailabilityCheckExpr: return Val_int(103);
case CXCursor_FixedPointLiteral: return Val_int(104);
case CXCursor_OMPArrayShapingExpr: return Val_int(105);
case CXCursor_OMPIteratorExpr: return Val_int(106);
case CXCursor_UnexposedStmt: return Val_int(107);
case CXCursor_LabelStmt: return Val_int(108);
case CXCursor_CompoundStmt: return Val_int(109);
case CXCursor_CaseStmt: return Val_int(110);
case CXCursor_DefaultStmt: return Val_int(111);
case CXCursor_IfStmt: return Val_int(112);
case CXCursor_SwitchStmt: return Val_int(113);
case CXCursor_WhileStmt: return Val_int(114);
case CXCursor_DoStmt: return Val_int(115);
case CXCursor_ForStmt: return Val_int(116);
case CXCursor_GotoStmt: return Val_int(117);
case CXCursor_IndirectGotoStmt: return Val_int(118);
case CXCursor_ContinueStmt: return Val_int(119);
case CXCursor_BreakStmt: return Val_int(120);
case CXCursor_ReturnStmt: return Val_int(121);
case CXCursor_GCCAsmStmt: return Val_int(122);
case CXCursor_ObjCAtTryStmt: return Val_int(123);
case CXCursor_ObjCAtCatchStmt: return Val_int(124);
case CXCursor_ObjCAtFinallyStmt: return Val_int(125);
case CXCursor_ObjCAtThrowStmt: return Val_int(126);
case CXCursor_ObjCAtSynchronizedStmt: return Val_int(127);
case CXCursor_ObjCAutoreleasePoolStmt: return Val_int(128);
case CXCursor_ObjCForCollectionStmt: return Val_int(129);
case CXCursor_CXXCatchStmt: return Val_int(130);
case CXCursor_CXXTryStmt: return Val_int(131);
case CXCursor_CXXForRangeStmt: return Val_int(132);
case CXCursor_SEHTryStmt: return Val_int(133);
case CXCursor_SEHExceptStmt: return Val_int(134);
case CXCursor_SEHFinallyStmt: return Val_int(135);
case CXCursor_MSAsmStmt: return Val_int(136);
case CXCursor_NullStmt: return Val_int(137);
case CXCursor_DeclStmt: return Val_int(138);
case CXCursor_OMPParallelDirective: return Val_int(139);
case CXCursor_OMPSimdDirective: return Val_int(140);
case CXCursor_OMPForDirective: return Val_int(141);
case CXCursor_OMPSectionsDirective: return Val_int(142);
case CXCursor_OMPSectionDirective: return Val_int(143);
case CXCursor_OMPSingleDirective: return Val_int(144);
case CXCursor_OMPParallelForDirective: return Val_int(145);
case CXCursor_OMPParallelSectionsDirective: return Val_int(146);
case CXCursor_OMPTaskDirective: return Val_int(147);
case CXCursor_OMPMasterDirective: return Val_int(148);
case CXCursor_OMPCriticalDirective: return Val_int(149);
case CXCursor_OMPTaskyieldDirective: return Val_int(150);
case CXCursor_OMPBarrierDirective: return Val_int(151);
case CXCursor_OMPTaskwaitDirective: return Val_int(152);
case CXCursor_OMPFlushDirective: return Val_int(153);
case CXCursor_SEHLeaveStmt: return Val_int(154);
case CXCursor_OMPOrderedDirective: return Val_int(155);
case CXCursor_OMPAtomicDirective: return Val_int(156);
case CXCursor_OMPForSimdDirective: return Val_int(157);
case CXCursor_OMPParallelForSimdDirective: return Val_int(158);
case CXCursor_OMPTargetDirective: return Val_int(159);
case CXCursor_OMPTeamsDirective: return Val_int(160);
case CXCursor_OMPTaskgroupDirective: return Val_int(161);
case CXCursor_OMPCancellationPointDirective: return Val_int(162);
case CXCursor_OMPCancelDirective: return Val_int(163);
case CXCursor_OMPTargetDataDirective: return Val_int(164);
case CXCursor_OMPTaskLoopDirective: return Val_int(165);
case CXCursor_OMPTaskLoopSimdDirective: return Val_int(166);
case CXCursor_OMPDistributeDirective: return Val_int(167);
case CXCursor_OMPTargetEnterDataDirective: return Val_int(168);
case CXCursor_OMPTargetExitDataDirective: return Val_int(169);
case CXCursor_OMPTargetParallelDirective: return Val_int(170);
case CXCursor_OMPTargetParallelForDirective: return Val_int(171);
case CXCursor_OMPTargetUpdateDirective: return Val_int(172);
case CXCursor_OMPDistributeParallelForDirective: return Val_int(173);
case CXCursor_OMPDistributeParallelForSimdDirective: return Val_int(174);
case CXCursor_OMPDistributeSimdDirective: return Val_int(175);
case CXCursor_OMPTargetParallelForSimdDirective: return Val_int(176);
case CXCursor_OMPTargetSimdDirective: return Val_int(177);
case CXCursor_OMPTeamsDistributeDirective: return Val_int(178);
case CXCursor_OMPTeamsDistributeSimdDirective: return Val_int(179);
case CXCursor_OMPTeamsDistributeParallelForSimdDirective: return Val_int(180);
case CXCursor_OMPTeamsDistributeParallelForDirective: return Val_int(181);
case CXCursor_OMPTargetTeamsDirective: return Val_int(182);
case CXCursor_OMPTargetTeamsDistributeDirective: return Val_int(183);
case CXCursor_OMPTargetTeamsDistributeParallelForDirective: return Val_int(184);
case CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective: return Val_int(185);
case CXCursor_OMPTargetTeamsDistributeSimdDirective: return Val_int(186);
case CXCursor_BuiltinBitCastExpr: return Val_int(187);
case CXCursor_OMPMasterTaskLoopDirective: return Val_int(188);
case CXCursor_OMPParallelMasterTaskLoopDirective: return Val_int(189);
case CXCursor_OMPMasterTaskLoopSimdDirective: return Val_int(190);
case CXCursor_OMPParallelMasterTaskLoopSimdDirective: return Val_int(191);
case CXCursor_OMPParallelMasterDirective: return Val_int(192);
case CXCursor_OMPDepobjDirective: return Val_int(193);
case CXCursor_OMPScanDirective: return Val_int(194);
case CXCursor_TranslationUnit: return Val_int(195);
case CXCursor_UnexposedAttr: return Val_int(196);
case CXCursor_IBActionAttr: return Val_int(197);
case CXCursor_IBOutletAttr: return Val_int(198);
case CXCursor_IBOutletCollectionAttr: return Val_int(199);
case CXCursor_CXXFinalAttr: return Val_int(200);
case CXCursor_CXXOverrideAttr: return Val_int(201);
case CXCursor_AnnotateAttr: return Val_int(202);
case CXCursor_AsmLabelAttr: return Val_int(203);
case CXCursor_PackedAttr: return Val_int(204);
case CXCursor_PureAttr: return Val_int(205);
case CXCursor_ConstAttr: return Val_int(206);
case CXCursor_NoDuplicateAttr: return Val_int(207);
case CXCursor_CUDAConstantAttr: return Val_int(208);
case CXCursor_CUDADeviceAttr: return Val_int(209);
case CXCursor_CUDAGlobalAttr: return Val_int(210);
case CXCursor_CUDAHostAttr: return Val_int(211);
case CXCursor_CUDASharedAttr: return Val_int(212);
case CXCursor_VisibilityAttr: return Val_int(213);
case CXCursor_DLLExport: return Val_int(214);
case CXCursor_DLLImport: return Val_int(215);
case CXCursor_NSReturnsRetained: return Val_int(216);
case CXCursor_NSReturnsNotRetained: return Val_int(217);
case CXCursor_NSReturnsAutoreleased: return Val_int(218);
case CXCursor_NSConsumesSelf: return Val_int(219);
case CXCursor_NSConsumed: return Val_int(220);
case CXCursor_ObjCException: return Val_int(221);
case CXCursor_ObjCNSObject: return Val_int(222);
case CXCursor_ObjCIndependentClass: return Val_int(223);
case CXCursor_ObjCPreciseLifetime: return Val_int(224);
case CXCursor_ObjCReturnsInnerPointer: return Val_int(225);
case CXCursor_ObjCRequiresSuper: return Val_int(226);
case CXCursor_ObjCRootClass: return Val_int(227);
case CXCursor_ObjCSubclassingRestricted: return Val_int(228);
case CXCursor_ObjCExplicitProtocolImpl: return Val_int(229);
case CXCursor_ObjCDesignatedInitializer: return Val_int(230);
case CXCursor_ObjCRuntimeVisible: return Val_int(231);
case CXCursor_ObjCBoxable: return Val_int(232);
case CXCursor_FlagEnum: return Val_int(233);
case CXCursor_ConvergentAttr: return Val_int(234);
case CXCursor_WarnUnusedAttr: return Val_int(235);
case CXCursor_WarnUnusedResultAttr: return Val_int(236);
case CXCursor_AlignedAttr: return Val_int(237);
case CXCursor_PreprocessingDirective: return Val_int(238);
case CXCursor_MacroDefinition: return Val_int(239);
case CXCursor_MacroExpansion: return Val_int(240);
case CXCursor_InclusionDirective: return Val_int(241);
case CXCursor_ModuleImportDecl: return Val_int(242);
case CXCursor_TypeAliasTemplateDecl: return Val_int(243);
case CXCursor_StaticAssert: return Val_int(244);
case CXCursor_FriendDecl: return Val_int(245);
case CXCursor_OverloadCandidate: return Val_int(246);
}
caml_failwith_fmt("invalid value for Val_cxcursorkind: %d", v);
return Val_int(0);
}
DECLARE_OPAQUE_EX(CXCursor, cxcursor, Cxcursor_val, Val_cxcursor, custom_finalize_default, clang_ext_compare_cursor, clang_ext_hash_cursor)
CAMLprim value
clang_getNullCursor_wrapper()
{
CAMLparam0();
CXCursor result = clang_getNullCursor();
{
CAMLlocal1(data);
data = caml_alloc_tuple(1);
Store_field(data, 0, Val_cxcursor(result));
CAMLreturn(data);
}
}
CAMLprim value
clang_getTranslationUnitCursor_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXCursor result = clang_getTranslationUnitCursor(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, arg_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_equalCursors_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor arg2;
arg2 = Cxcursor_val(Field(arg2_ocaml, 0));
unsigned int result = clang_equalCursors(arg, arg2);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isNull_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_Cursor_isNull(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_hashCursor_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_hashCursor(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum CXCursorKind result = clang_getCursorKind(arg);
{
CAMLlocal1(data);
data = Val_cxcursorkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isDeclaration_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isDeclaration(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isInvalidDeclaration_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_isInvalidDeclaration(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isReference_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isReference(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isExpression_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isExpression(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isStatement_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isStatement(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isAttribute_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isAttribute(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_hasAttrs_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_hasAttrs(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isInvalid_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isInvalid(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isTranslationUnit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isTranslationUnit(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isPreprocessing_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isPreprocessing(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isUnexposed_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
unsigned int result = clang_isUnexposed(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum CXLinkageKind
Cxlinkagekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXLinkage_Invalid;
case 1: return CXLinkage_NoLinkage;
case 2: return CXLinkage_Internal;
case 3: return CXLinkage_UniqueExternal;
case 4: return CXLinkage_External;
}
caml_failwith_fmt("invalid value for Cxlinkagekind_val: %d", Int_val(ocaml));
return CXLinkage_Invalid;
}
value
Val_cxlinkagekind(enum CXLinkageKind v)
{
switch (v) {
case CXLinkage_Invalid: return Val_int(0);
case CXLinkage_NoLinkage: return Val_int(1);
case CXLinkage_Internal: return Val_int(2);
case CXLinkage_UniqueExternal: return Val_int(3);
case CXLinkage_External: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_cxlinkagekind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getCursorLinkage_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum CXLinkageKind result = clang_getCursorLinkage(cursor);
{
CAMLlocal1(data);
data = Val_cxlinkagekind(result);
CAMLreturn(data);
}
}
enum CXVisibilityKind
Cxvisibilitykind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXVisibility_Invalid;
case 1: return CXVisibility_Hidden;
case 2: return CXVisibility_Protected;
case 3: return CXVisibility_Default;
}
caml_failwith_fmt("invalid value for Cxvisibilitykind_val: %d", Int_val(ocaml));
return CXVisibility_Invalid;
}
value
Val_cxvisibilitykind(enum CXVisibilityKind v)
{
switch (v) {
case CXVisibility_Invalid: return Val_int(0);
case CXVisibility_Hidden: return Val_int(1);
case CXVisibility_Protected: return Val_int(2);
case CXVisibility_Default: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_cxvisibilitykind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getCursorVisibility_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum CXVisibilityKind result = clang_getCursorVisibility(cursor);
{
CAMLlocal1(data);
data = Val_cxvisibilitykind(result);
CAMLreturn(data);
}
}
enum CXAvailabilityKind
Cxavailabilitykind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXAvailability_Available;
case 1: return CXAvailability_Deprecated;
case 2: return CXAvailability_NotAvailable;
case 3: return CXAvailability_NotAccessible;
}
caml_failwith_fmt("invalid value for Cxavailabilitykind_val: %d", Int_val(ocaml));
return CXAvailability_Available;
}
value
Val_cxavailabilitykind(enum CXAvailabilityKind v)
{
switch (v) {
case CXAvailability_Available: return Val_int(0);
case CXAvailability_Deprecated: return Val_int(1);
case CXAvailability_NotAvailable: return Val_int(2);
case CXAvailability_NotAccessible: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_cxavailabilitykind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getCursorAvailability_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum CXAvailabilityKind result = clang_getCursorAvailability(cursor);
{
CAMLlocal1(data);
data = Val_cxavailabilitykind(result);
CAMLreturn(data);
}
}
enum CXLanguageKind
Cxlanguagekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXLanguage_Invalid;
case 1: return CXLanguage_C;
case 2: return CXLanguage_ObjC;
case 3: return CXLanguage_CPlusPlus;
}
caml_failwith_fmt("invalid value for Cxlanguagekind_val: %d", Int_val(ocaml));
return CXLanguage_Invalid;
}
value
Val_cxlanguagekind(enum CXLanguageKind v)
{
switch (v) {
case CXLanguage_Invalid: return Val_int(0);
case CXLanguage_C: return Val_int(1);
case CXLanguage_ObjC: return Val_int(2);
case CXLanguage_CPlusPlus: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_cxlanguagekind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getCursorLanguage_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum CXLanguageKind result = clang_getCursorLanguage(cursor);
{
CAMLlocal1(data);
data = Val_cxlanguagekind(result);
CAMLreturn(data);
}
}
enum CXTLSKind
Cxtlskind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXTLS_None;
case 1: return CXTLS_Dynamic;
case 2: return CXTLS_Static;
}
caml_failwith_fmt("invalid value for Cxtlskind_val: %d", Int_val(ocaml));
return CXTLS_None;
}
value
Val_cxtlskind(enum CXTLSKind v)
{
switch (v) {
case CXTLS_None: return Val_int(0);
case CXTLS_Dynamic: return Val_int(1);
case CXTLS_Static: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_cxtlskind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getCursorTLSKind_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum CXTLSKind result = clang_getCursorTLSKind(cursor);
{
CAMLlocal1(data);
data = Val_cxtlskind(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXCursorSet, cxcursorset, Cxcursorset_val, Val_cxcursorset, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_createCXCursorSet_wrapper()
{
CAMLparam0();
CXCursorSet result = clang_createCXCursorSet();
{
CAMLlocal1(data);
data = Val_cxcursorset(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXCursorSet_contains_wrapper(value cset_ocaml, value cursor_ocaml)
{
CAMLparam2(cset_ocaml, cursor_ocaml);
CXCursorSet cset;
cset = Cxcursorset_val(cset_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_CXCursorSet_contains(cset, cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXCursorSet_insert_wrapper(value cset_ocaml, value cursor_ocaml)
{
CAMLparam2(cset_ocaml, cursor_ocaml);
CXCursorSet cset;
cset = Cxcursorset_val(cset_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_CXCursorSet_insert(cset, cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorSemanticParent_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_getCursorSemanticParent(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorLexicalParent_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_getCursorLexicalParent(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getOverriddenCursors_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int num_overridden;
CXCursor * overridden;
clang_getOverriddenCursors(cursor, &overridden, &num_overridden);
{
CAMLlocal1(data);
data = caml_alloc(num_overridden, 0);
CAMLlocal1(cell);
for (unsigned int i = 0; i < num_overridden; i++) {
cell = caml_alloc_tuple(1);
Store_field(cell, 0, Val_cxcursor(overridden[i]));
Store_field(data, i, cell);
}
clang_disposeOverriddenCursors(overridden);
CAMLreturn(data);
}
}
CAMLprim value
clang_getIncludedFile_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXFile result = clang_getIncludedFile(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxfile(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursor_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXSourceLocation arg2;
arg2 = Cxsourcelocation_val(Field(arg2_ocaml, 0));
CXCursor result = clang_getCursor(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, arg_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorLocation_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXSourceLocation result = clang_getCursorLocation(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcelocation(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorExtent_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXSourceRange result = clang_getCursorExtent(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcerange(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum CXTypeKind
Cxtypekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXType_Invalid;
case 1: return CXType_Unexposed;
case 2: return CXType_Void;
case 3: return CXType_Bool;
case 4: return CXType_Char_U;
case 5: return CXType_UChar;
case 6: return CXType_Char16;
case 7: return CXType_Char32;
case 8: return CXType_UShort;
case 9: return CXType_UInt;
case 10: return CXType_ULong;
case 11: return CXType_ULongLong;
case 12: return CXType_UInt128;
case 13: return CXType_Char_S;
case 14: return CXType_SChar;
case 15: return CXType_WChar;
case 16: return CXType_Short;
case 17: return CXType_Int;
case 18: return CXType_Long;
case 19: return CXType_LongLong;
case 20: return CXType_Int128;
case 21: return CXType_Float;
case 22: return CXType_Double;
case 23: return CXType_LongDouble;
case 24: return CXType_NullPtr;
case 25: return CXType_Overload;
case 26: return CXType_Dependent;
case 27: return CXType_ObjCId;
case 28: return CXType_ObjCClass;
case 29: return CXType_ObjCSel;
case 30: return CXType_Float128;
case 31: return CXType_Half;
case 32: return CXType_Float16;
case 33: return CXType_ShortAccum;
case 34: return CXType_Accum;
case 35: return CXType_LongAccum;
case 36: return CXType_UShortAccum;
case 37: return CXType_UAccum;
case 38: return CXType_ULongAccum;
case 39: return CXType_BFloat16;
case 40: return CXType_Complex;
case 41: return CXType_Pointer;
case 42: return CXType_BlockPointer;
case 43: return CXType_LValueReference;
case 44: return CXType_RValueReference;
case 45: return CXType_Record;
case 46: return CXType_Enum;
case 47: return CXType_Typedef;
case 48: return CXType_ObjCInterface;
case 49: return CXType_ObjCObjectPointer;
case 50: return CXType_FunctionNoProto;
case 51: return CXType_FunctionProto;
case 52: return CXType_ConstantArray;
case 53: return CXType_Vector;
case 54: return CXType_IncompleteArray;
case 55: return CXType_VariableArray;
case 56: return CXType_DependentSizedArray;
case 57: return CXType_MemberPointer;
case 58: return CXType_Auto;
case 59: return CXType_Elaborated;
case 60: return CXType_Pipe;
case 61: return CXType_OCLImage1dRO;
case 62: return CXType_OCLImage1dArrayRO;
case 63: return CXType_OCLImage1dBufferRO;
case 64: return CXType_OCLImage2dRO;
case 65: return CXType_OCLImage2dArrayRO;
case 66: return CXType_OCLImage2dDepthRO;
case 67: return CXType_OCLImage2dArrayDepthRO;
case 68: return CXType_OCLImage2dMSAARO;
case 69: return CXType_OCLImage2dArrayMSAARO;
case 70: return CXType_OCLImage2dMSAADepthRO;
case 71: return CXType_OCLImage2dArrayMSAADepthRO;
case 72: return CXType_OCLImage3dRO;
case 73: return CXType_OCLImage1dWO;
case 74: return CXType_OCLImage1dArrayWO;
case 75: return CXType_OCLImage1dBufferWO;
case 76: return CXType_OCLImage2dWO;
case 77: return CXType_OCLImage2dArrayWO;
case 78: return CXType_OCLImage2dDepthWO;
case 79: return CXType_OCLImage2dArrayDepthWO;
case 80: return CXType_OCLImage2dMSAAWO;
case 81: return CXType_OCLImage2dArrayMSAAWO;
case 82: return CXType_OCLImage2dMSAADepthWO;
case 83: return CXType_OCLImage2dArrayMSAADepthWO;
case 84: return CXType_OCLImage3dWO;
case 85: return CXType_OCLImage1dRW;
case 86: return CXType_OCLImage1dArrayRW;
case 87: return CXType_OCLImage1dBufferRW;
case 88: return CXType_OCLImage2dRW;
case 89: return CXType_OCLImage2dArrayRW;
case 90: return CXType_OCLImage2dDepthRW;
case 91: return CXType_OCLImage2dArrayDepthRW;
case 92: return CXType_OCLImage2dMSAARW;
case 93: return CXType_OCLImage2dArrayMSAARW;
case 94: return CXType_OCLImage2dMSAADepthRW;
case 95: return CXType_OCLImage2dArrayMSAADepthRW;
case 96: return CXType_OCLImage3dRW;
case 97: return CXType_OCLSampler;
case 98: return CXType_OCLEvent;
case 99: return CXType_OCLQueue;
case 100: return CXType_OCLReserveID;
case 101: return CXType_ObjCObject;
case 102: return CXType_ObjCTypeParam;
case 103: return CXType_Attributed;
case 104: return CXType_OCLIntelSubgroupAVCMcePayload;
case 105: return CXType_OCLIntelSubgroupAVCImePayload;
case 106: return CXType_OCLIntelSubgroupAVCRefPayload;
case 107: return CXType_OCLIntelSubgroupAVCSicPayload;
case 108: return CXType_OCLIntelSubgroupAVCMceResult;
case 109: return CXType_OCLIntelSubgroupAVCImeResult;
case 110: return CXType_OCLIntelSubgroupAVCRefResult;
case 111: return CXType_OCLIntelSubgroupAVCSicResult;
case 112: return CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout;
case 113: return CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout;
case 114: return CXType_OCLIntelSubgroupAVCImeSingleRefStreamin;
case 115: return CXType_OCLIntelSubgroupAVCImeDualRefStreamin;
case 116: return CXType_ExtVector;
case 117: return CXType_Atomic;
}
caml_failwith_fmt("invalid value for Cxtypekind_val: %d", Int_val(ocaml));
return CXType_Invalid;
}
value
Val_cxtypekind(enum CXTypeKind v)
{
switch (v) {
case CXType_Invalid: return Val_int(0);
case CXType_Unexposed: return Val_int(1);
case CXType_Void: return Val_int(2);
case CXType_Bool: return Val_int(3);
case CXType_Char_U: return Val_int(4);
case CXType_UChar: return Val_int(5);
case CXType_Char16: return Val_int(6);
case CXType_Char32: return Val_int(7);
case CXType_UShort: return Val_int(8);
case CXType_UInt: return Val_int(9);
case CXType_ULong: return Val_int(10);
case CXType_ULongLong: return Val_int(11);
case CXType_UInt128: return Val_int(12);
case CXType_Char_S: return Val_int(13);
case CXType_SChar: return Val_int(14);
case CXType_WChar: return Val_int(15);
case CXType_Short: return Val_int(16);
case CXType_Int: return Val_int(17);
case CXType_Long: return Val_int(18);
case CXType_LongLong: return Val_int(19);
case CXType_Int128: return Val_int(20);
case CXType_Float: return Val_int(21);
case CXType_Double: return Val_int(22);
case CXType_LongDouble: return Val_int(23);
case CXType_NullPtr: return Val_int(24);
case CXType_Overload: return Val_int(25);
case CXType_Dependent: return Val_int(26);
case CXType_ObjCId: return Val_int(27);
case CXType_ObjCClass: return Val_int(28);
case CXType_ObjCSel: return Val_int(29);
case CXType_Float128: return Val_int(30);
case CXType_Half: return Val_int(31);
case CXType_Float16: return Val_int(32);
case CXType_ShortAccum: return Val_int(33);
case CXType_Accum: return Val_int(34);
case CXType_LongAccum: return Val_int(35);
case CXType_UShortAccum: return Val_int(36);
case CXType_UAccum: return Val_int(37);
case CXType_ULongAccum: return Val_int(38);
case CXType_BFloat16: return Val_int(39);
case CXType_Complex: return Val_int(40);
case CXType_Pointer: return Val_int(41);
case CXType_BlockPointer: return Val_int(42);
case CXType_LValueReference: return Val_int(43);
case CXType_RValueReference: return Val_int(44);
case CXType_Record: return Val_int(45);
case CXType_Enum: return Val_int(46);
case CXType_Typedef: return Val_int(47);
case CXType_ObjCInterface: return Val_int(48);
case CXType_ObjCObjectPointer: return Val_int(49);
case CXType_FunctionNoProto: return Val_int(50);
case CXType_FunctionProto: return Val_int(51);
case CXType_ConstantArray: return Val_int(52);
case CXType_Vector: return Val_int(53);
case CXType_IncompleteArray: return Val_int(54);
case CXType_VariableArray: return Val_int(55);
case CXType_DependentSizedArray: return Val_int(56);
case CXType_MemberPointer: return Val_int(57);
case CXType_Auto: return Val_int(58);
case CXType_Elaborated: return Val_int(59);
case CXType_Pipe: return Val_int(60);
case CXType_OCLImage1dRO: return Val_int(61);
case CXType_OCLImage1dArrayRO: return Val_int(62);
case CXType_OCLImage1dBufferRO: return Val_int(63);
case CXType_OCLImage2dRO: return Val_int(64);
case CXType_OCLImage2dArrayRO: return Val_int(65);
case CXType_OCLImage2dDepthRO: return Val_int(66);
case CXType_OCLImage2dArrayDepthRO: return Val_int(67);
case CXType_OCLImage2dMSAARO: return Val_int(68);
case CXType_OCLImage2dArrayMSAARO: return Val_int(69);
case CXType_OCLImage2dMSAADepthRO: return Val_int(70);
case CXType_OCLImage2dArrayMSAADepthRO: return Val_int(71);
case CXType_OCLImage3dRO: return Val_int(72);
case CXType_OCLImage1dWO: return Val_int(73);
case CXType_OCLImage1dArrayWO: return Val_int(74);
case CXType_OCLImage1dBufferWO: return Val_int(75);
case CXType_OCLImage2dWO: return Val_int(76);
case CXType_OCLImage2dArrayWO: return Val_int(77);
case CXType_OCLImage2dDepthWO: return Val_int(78);
case CXType_OCLImage2dArrayDepthWO: return Val_int(79);
case CXType_OCLImage2dMSAAWO: return Val_int(80);
case CXType_OCLImage2dArrayMSAAWO: return Val_int(81);
case CXType_OCLImage2dMSAADepthWO: return Val_int(82);
case CXType_OCLImage2dArrayMSAADepthWO: return Val_int(83);
case CXType_OCLImage3dWO: return Val_int(84);
case CXType_OCLImage1dRW: return Val_int(85);
case CXType_OCLImage1dArrayRW: return Val_int(86);
case CXType_OCLImage1dBufferRW: return Val_int(87);
case CXType_OCLImage2dRW: return Val_int(88);
case CXType_OCLImage2dArrayRW: return Val_int(89);
case CXType_OCLImage2dDepthRW: return Val_int(90);
case CXType_OCLImage2dArrayDepthRW: return Val_int(91);
case CXType_OCLImage2dMSAARW: return Val_int(92);
case CXType_OCLImage2dArrayMSAARW: return Val_int(93);
case CXType_OCLImage2dMSAADepthRW: return Val_int(94);
case CXType_OCLImage2dArrayMSAADepthRW: return Val_int(95);
case CXType_OCLImage3dRW: return Val_int(96);
case CXType_OCLSampler: return Val_int(97);
case CXType_OCLEvent: return Val_int(98);
case CXType_OCLQueue: return Val_int(99);
case CXType_OCLReserveID: return Val_int(100);
case CXType_ObjCObject: return Val_int(101);
case CXType_ObjCTypeParam: return Val_int(102);
case CXType_Attributed: return Val_int(103);
case CXType_OCLIntelSubgroupAVCMcePayload: return Val_int(104);
case CXType_OCLIntelSubgroupAVCImePayload: return Val_int(105);
case CXType_OCLIntelSubgroupAVCRefPayload: return Val_int(106);
case CXType_OCLIntelSubgroupAVCSicPayload: return Val_int(107);
case CXType_OCLIntelSubgroupAVCMceResult: return Val_int(108);
case CXType_OCLIntelSubgroupAVCImeResult: return Val_int(109);
case CXType_OCLIntelSubgroupAVCRefResult: return Val_int(110);
case CXType_OCLIntelSubgroupAVCSicResult: return Val_int(111);
case CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout: return Val_int(112);
case CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout: return Val_int(113);
case CXType_OCLIntelSubgroupAVCImeSingleRefStreamin: return Val_int(114);
case CXType_OCLIntelSubgroupAVCImeDualRefStreamin: return Val_int(115);
case CXType_ExtVector: return Val_int(116);
case CXType_Atomic: return Val_int(117);
}
caml_failwith_fmt("invalid value for Val_cxtypekind: %d", v);
return Val_int(0);
}
DECLARE_OPAQUE_EX(CXType, cxtype, Cxtype_val, Val_cxtype, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getTypeKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
enum CXTypeKind result = arg.kind;
{
CAMLlocal1(data);
data = Val_cxtypekind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorType_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXType result = clang_getCursorType(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getTypeSpelling_wrapper(value CT_ocaml)
{
CAMLparam1(CT_ocaml);
CXType CT;
CT = Cxtype_val(Field(CT_ocaml, 0));
CXString result = clang_getTypeSpelling(CT);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getTypedefDeclUnderlyingType_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXType result = clang_getTypedefDeclUnderlyingType(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getEnumDeclIntegerType_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXType result = clang_getEnumDeclIntegerType(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getEnumConstantDeclValue_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
long long result = clang_getEnumConstantDeclValue(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getEnumConstantDeclUnsignedValue_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned long long result = clang_getEnumConstantDeclUnsignedValue(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getFieldDeclBitWidth_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
int result = clang_getFieldDeclBitWidth(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getNumArguments_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
int result = clang_Cursor_getNumArguments(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getArgument_wrapper(value C_ocaml, value i_ocaml)
{
CAMLparam2(C_ocaml, i_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int i;
i = Int_val(i_ocaml);
CXCursor result = clang_Cursor_getArgument(C, i);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getNumTemplateArguments_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
int result = clang_Cursor_getNumTemplateArguments(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum CXTemplateArgumentKind
Cxtemplateargumentkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXTemplateArgumentKind_Null;
case 1: return CXTemplateArgumentKind_Type;
case 2: return CXTemplateArgumentKind_Declaration;
case 3: return CXTemplateArgumentKind_NullPtr;
case 4: return CXTemplateArgumentKind_Integral;
case 5: return CXTemplateArgumentKind_Template;
case 6: return CXTemplateArgumentKind_TemplateExpansion;
case 7: return CXTemplateArgumentKind_Expression;
case 8: return CXTemplateArgumentKind_Pack;
case 9: return CXTemplateArgumentKind_Invalid;
}
caml_failwith_fmt("invalid value for Cxtemplateargumentkind_val: %d", Int_val(ocaml));
return CXTemplateArgumentKind_Null;
}
value
Val_cxtemplateargumentkind(enum CXTemplateArgumentKind v)
{
switch (v) {
case CXTemplateArgumentKind_Null: return Val_int(0);
case CXTemplateArgumentKind_Type: return Val_int(1);
case CXTemplateArgumentKind_Declaration: return Val_int(2);
case CXTemplateArgumentKind_NullPtr: return Val_int(3);
case CXTemplateArgumentKind_Integral: return Val_int(4);
case CXTemplateArgumentKind_Template: return Val_int(5);
case CXTemplateArgumentKind_TemplateExpansion: return Val_int(6);
case CXTemplateArgumentKind_Expression: return Val_int(7);
case CXTemplateArgumentKind_Pack: return Val_int(8);
case CXTemplateArgumentKind_Invalid: return Val_int(9);
}
caml_failwith_fmt("invalid value for Val_cxtemplateargumentkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_Cursor_getTemplateArgumentKind_wrapper(value C_ocaml, value I_ocaml)
{
CAMLparam2(C_ocaml, I_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int I;
I = Int_val(I_ocaml);
enum CXTemplateArgumentKind result = clang_Cursor_getTemplateArgumentKind(C, I);
{
CAMLlocal1(data);
data = Val_cxtemplateargumentkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getTemplateArgumentType_wrapper(value C_ocaml, value I_ocaml)
{
CAMLparam2(C_ocaml, I_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int I;
I = Int_val(I_ocaml);
CXType result = clang_Cursor_getTemplateArgumentType(C, I);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getTemplateArgumentValue_wrapper(value C_ocaml, value I_ocaml)
{
CAMLparam2(C_ocaml, I_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int I;
I = Int_val(I_ocaml);
long long result = clang_Cursor_getTemplateArgumentValue(C, I);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getTemplateArgumentUnsignedValue_wrapper(value C_ocaml, value I_ocaml)
{
CAMLparam2(C_ocaml, I_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int I;
I = Int_val(I_ocaml);
unsigned long long result = clang_Cursor_getTemplateArgumentUnsignedValue(C, I);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_equalTypes_wrapper(value A_ocaml, value B_ocaml)
{
CAMLparam2(A_ocaml, B_ocaml);
CXType A;
A = Cxtype_val(Field(A_ocaml, 0));
CXType B;
B = Cxtype_val(Field(B_ocaml, 0));
unsigned int result = clang_equalTypes(A, B);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCanonicalType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_getCanonicalType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_isConstQualifiedType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_isConstQualifiedType(T);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isMacroFunctionLike_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isMacroFunctionLike(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isMacroBuiltin_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isMacroBuiltin(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isFunctionInlined_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isFunctionInlined(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isVolatileQualifiedType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_isVolatileQualifiedType(T);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isRestrictQualifiedType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_isRestrictQualifiedType(T);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getAddressSpace_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_getAddressSpace(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getTypedefName_wrapper(value CT_ocaml)
{
CAMLparam1(CT_ocaml);
CXType CT;
CT = Cxtype_val(Field(CT_ocaml, 0));
CXString result = clang_getTypedefName(CT);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getPointeeType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_getPointeeType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getTypeDeclaration_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXCursor result = clang_getTypeDeclaration(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getDeclObjCTypeEncoding_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXString result = clang_getDeclObjCTypeEncoding(C);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getObjCEncoding_wrapper(value type_ocaml)
{
CAMLparam1(type_ocaml);
CXType type;
type = Cxtype_val(Field(type_ocaml, 0));
CXString result = clang_Type_getObjCEncoding(type);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getTypeKindSpelling_wrapper(value K_ocaml)
{
CAMLparam1(K_ocaml);
enum CXTypeKind K;
K = Cxtypekind_val(K_ocaml);
CXString result = clang_getTypeKindSpelling(K);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
enum CXCallingConv
Cxcallingconv_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXCallingConv_Default;
case 1: return CXCallingConv_C;
case 2: return CXCallingConv_X86StdCall;
case 3: return CXCallingConv_X86FastCall;
case 4: return CXCallingConv_X86ThisCall;
case 5: return CXCallingConv_X86Pascal;
case 6: return CXCallingConv_AAPCS;
case 7: return CXCallingConv_AAPCS_VFP;
case 8: return CXCallingConv_X86RegCall;
case 9: return CXCallingConv_IntelOclBicc;
case 10: return CXCallingConv_Win64;
case 11: return CXCallingConv_X86_64SysV;
case 12: return CXCallingConv_X86VectorCall;
case 13: return CXCallingConv_Swift;
case 14: return CXCallingConv_PreserveMost;
case 15: return CXCallingConv_PreserveAll;
case 16: return CXCallingConv_AArch64VectorCall;
case 17: return CXCallingConv_Invalid;
case 18: return CXCallingConv_Unexposed;
}
caml_failwith_fmt("invalid value for Cxcallingconv_val: %d", Int_val(ocaml));
return CXCallingConv_Default;
}
value
Val_cxcallingconv(enum CXCallingConv v)
{
switch (v) {
case CXCallingConv_Default: return Val_int(0);
case CXCallingConv_C: return Val_int(1);
case CXCallingConv_X86StdCall: return Val_int(2);
case CXCallingConv_X86FastCall: return Val_int(3);
case CXCallingConv_X86ThisCall: return Val_int(4);
case CXCallingConv_X86Pascal: return Val_int(5);
case CXCallingConv_AAPCS: return Val_int(6);
case CXCallingConv_AAPCS_VFP: return Val_int(7);
case CXCallingConv_X86RegCall: return Val_int(8);
case CXCallingConv_IntelOclBicc: return Val_int(9);
case CXCallingConv_Win64: return Val_int(10);
case CXCallingConv_X86_64SysV: return Val_int(11);
case CXCallingConv_X86VectorCall: return Val_int(12);
case CXCallingConv_Swift: return Val_int(13);
case CXCallingConv_PreserveMost: return Val_int(14);
case CXCallingConv_PreserveAll: return Val_int(15);
case CXCallingConv_AArch64VectorCall: return Val_int(16);
case CXCallingConv_Invalid: return Val_int(17);
case CXCallingConv_Unexposed: return Val_int(18);
}
caml_failwith_fmt("invalid value for Val_cxcallingconv: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getFunctionTypeCallingConv_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
enum CXCallingConv result = clang_getFunctionTypeCallingConv(T);
{
CAMLlocal1(data);
data = Val_cxcallingconv(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getResultType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_getResultType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getExceptionSpecificationType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
int result = clang_getExceptionSpecificationType(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getNumArgTypes_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
int result = clang_getNumArgTypes(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getArgType_wrapper(value T_ocaml, value i_ocaml)
{
CAMLparam2(T_ocaml, i_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int i;
i = Int_val(i_ocaml);
CXType result = clang_getArgType(T, i);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getObjCObjectBaseType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_Type_getObjCObjectBaseType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getNumObjCProtocolRefs_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_Type_getNumObjCProtocolRefs(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getObjCProtocolDecl_wrapper(value T_ocaml, value i_ocaml)
{
CAMLparam2(T_ocaml, i_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int i;
i = Int_val(i_ocaml);
CXCursor result = clang_Type_getObjCProtocolDecl(T, i);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getNumObjCTypeArgs_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_Type_getNumObjCTypeArgs(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getObjCTypeArg_wrapper(value T_ocaml, value i_ocaml)
{
CAMLparam2(T_ocaml, i_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int i;
i = Int_val(i_ocaml);
CXType result = clang_Type_getObjCTypeArg(T, i);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_isFunctionTypeVariadic_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_isFunctionTypeVariadic(T);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorResultType_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXType result = clang_getCursorResultType(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorExceptionSpecificationType_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
int result = clang_getCursorExceptionSpecificationType(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isPODType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_isPODType(T);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getElementType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_getElementType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getNumElements_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
long long result = clang_getNumElements(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getArrayElementType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_getArrayElementType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getArraySize_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
long long result = clang_getArraySize(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getNamedType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_Type_getNamedType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_isTransparentTagTypedef_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_Type_isTransparentTagTypedef(T);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum CXTypeNullabilityKind
Cxtypenullabilitykind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXTypeNullability_NonNull;
case 1: return CXTypeNullability_Nullable;
case 2: return CXTypeNullability_Unspecified;
case 3: return CXTypeNullability_Invalid;
}
caml_failwith_fmt("invalid value for Cxtypenullabilitykind_val: %d", Int_val(ocaml));
return CXTypeNullability_NonNull;
}
value
Val_cxtypenullabilitykind(enum CXTypeNullabilityKind v)
{
switch (v) {
case CXTypeNullability_NonNull: return Val_int(0);
case CXTypeNullability_Nullable: return Val_int(1);
case CXTypeNullability_Unspecified: return Val_int(2);
case CXTypeNullability_Invalid: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_cxtypenullabilitykind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_Type_getNullability_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
enum CXTypeNullabilityKind result = clang_Type_getNullability(T);
{
CAMLlocal1(data);
data = Val_cxtypenullabilitykind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getAlignOf_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
long long result = clang_Type_getAlignOf(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getClassType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_Type_getClassType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getSizeOf_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
long long result = clang_Type_getSizeOf(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getOffsetOf_wrapper(value T_ocaml, value S_ocaml)
{
CAMLparam2(T_ocaml, S_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
const char * S;
S = String_val(S_ocaml);
long long result = clang_Type_getOffsetOf(T, S);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getModifiedType_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
CXType result = clang_Type_getModifiedType(T);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getValueType_wrapper(value CT_ocaml)
{
CAMLparam1(CT_ocaml);
CXType CT;
CT = Cxtype_val(Field(CT_ocaml, 0));
CXType result = clang_Type_getValueType(CT);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(CT_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getOffsetOfField_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
long long result = clang_Cursor_getOffsetOfField(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isAnonymous_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isAnonymous(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isAnonymousRecordDecl_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isAnonymousRecordDecl(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isInlineNamespace_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isInlineNamespace(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getNumTemplateArguments_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
int result = clang_Type_getNumTemplateArguments(T);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Type_getTemplateArgumentAsType_wrapper(value T_ocaml, value i_ocaml)
{
CAMLparam2(T_ocaml, i_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int i;
i = Int_val(i_ocaml);
CXType result = clang_Type_getTemplateArgumentAsType(T, i);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(T_ocaml, 1));
CAMLreturn(data);
}
}
enum CXRefQualifierKind
Cxrefqualifierkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXRefQualifier_None;
case 1: return CXRefQualifier_LValue;
case 2: return CXRefQualifier_RValue;
}
caml_failwith_fmt("invalid value for Cxrefqualifierkind_val: %d", Int_val(ocaml));
return CXRefQualifier_None;
}
value
Val_cxrefqualifierkind(enum CXRefQualifierKind v)
{
switch (v) {
case CXRefQualifier_None: return Val_int(0);
case CXRefQualifier_LValue: return Val_int(1);
case CXRefQualifier_RValue: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_cxrefqualifierkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_Type_getCXXRefQualifier_wrapper(value T_ocaml)
{
CAMLparam1(T_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
enum CXRefQualifierKind result = clang_Type_getCXXRefQualifier(T);
{
CAMLlocal1(data);
data = Val_cxrefqualifierkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isBitField_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isBitField(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_isVirtualBase_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_isVirtualBase(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum CX_CXXAccessSpecifier
Cx_cxxaccessspecifier_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CX_CXXInvalidAccessSpecifier;
case 1: return CX_CXXPublic;
case 2: return CX_CXXProtected;
case 3: return CX_CXXPrivate;
}
caml_failwith_fmt("invalid value for Cx_cxxaccessspecifier_val: %d", Int_val(ocaml));
return CX_CXXInvalidAccessSpecifier;
}
value
Val_cx_cxxaccessspecifier(enum CX_CXXAccessSpecifier v)
{
switch (v) {
case CX_CXXInvalidAccessSpecifier: return Val_int(0);
case CX_CXXPublic: return Val_int(1);
case CX_CXXProtected: return Val_int(2);
case CX_CXXPrivate: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_cx_cxxaccessspecifier: %d", v);
return Val_int(0);
}
CAMLprim value
clang_getCXXAccessSpecifier_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum CX_CXXAccessSpecifier result = clang_getCXXAccessSpecifier(arg);
{
CAMLlocal1(data);
data = Val_cx_cxxaccessspecifier(result);
CAMLreturn(data);
}
}
enum CX_StorageClass
Cx_storageclass_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CX_SC_Invalid;
case 1: return CX_SC_None;
case 2: return CX_SC_Extern;
case 3: return CX_SC_Static;
case 4: return CX_SC_PrivateExtern;
case 5: return CX_SC_OpenCLWorkGroupLocal;
case 6: return CX_SC_Auto;
case 7: return CX_SC_Register;
}
caml_failwith_fmt("invalid value for Cx_storageclass_val: %d", Int_val(ocaml));
return CX_SC_Invalid;
}
value
Val_cx_storageclass(enum CX_StorageClass v)
{
switch (v) {
case CX_SC_Invalid: return Val_int(0);
case CX_SC_None: return Val_int(1);
case CX_SC_Extern: return Val_int(2);
case CX_SC_Static: return Val_int(3);
case CX_SC_PrivateExtern: return Val_int(4);
case CX_SC_OpenCLWorkGroupLocal: return Val_int(5);
case CX_SC_Auto: return Val_int(6);
case CX_SC_Register: return Val_int(7);
}
caml_failwith_fmt("invalid value for Val_cx_storageclass: %d", v);
return Val_int(0);
}
CAMLprim value
clang_Cursor_getStorageClass_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum CX_StorageClass result = clang_Cursor_getStorageClass(arg);
{
CAMLlocal1(data);
data = Val_cx_storageclass(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getNumOverloadedDecls_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_getNumOverloadedDecls(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getOverloadedDecl_wrapper(value cursor_ocaml, value index_ocaml)
{
CAMLparam2(cursor_ocaml, index_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int index;
index = Int_val(index_ocaml);
CXCursor result = clang_getOverloadedDecl(cursor, index);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getIBOutletCollectionType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXType result = clang_getIBOutletCollectionType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum CXChildVisitResult
Cxchildvisitresult_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXChildVisit_Break;
case 1: return CXChildVisit_Continue;
case 2: return CXChildVisit_Recurse;
}
caml_failwith_fmt("invalid value for Cxchildvisitresult_val: %d", Int_val(ocaml));
return CXChildVisit_Break;
}
value
Val_cxchildvisitresult(enum CXChildVisitResult v)
{
switch (v) {
case CXChildVisit_Break: return Val_int(0);
case CXChildVisit_Continue: return Val_int(1);
case CXChildVisit_Recurse: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_cxchildvisitresult: %d", v);
return Val_int(0);
}
enum CXChildVisitResult
clang_visitChildren_visitor_callback(CXCursor arg0, CXCursor arg1, CXClientData arg2)
{
CAMLparam0();
CAMLlocal4(result, f, arg0_ocaml, arg1_ocaml);
f = *((value *) ((value **)arg2)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg2)[1], 1));arg1_ocaml = caml_alloc_tuple(2);
Store_field(arg1_ocaml, 0, Val_cxcursor(arg1));
Store_field(arg1_ocaml, 1, safe_field(*((value **)arg2)[1], 1)); result = caml_callback2(f, arg0_ocaml, arg1_ocaml);
{
CAMLlocal1(data);
data = Cxchildvisitresult_val(result);
CAMLreturnT(enum CXChildVisitResult, data);
}
}
CAMLprim value
clang_visitChildren_wrapper(value parent_ocaml, value visitor_ocaml)
{
CAMLparam2(parent_ocaml, visitor_ocaml);
CXCursor parent;
parent = Cxcursor_val(Field(parent_ocaml, 0));
unsigned int result = clang_visitChildren(parent, clang_visitChildren_visitor_callback, (value *[]){&visitor_ocaml,&parent_ocaml});
{
CAMLlocal1(data);
data = Val_not_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorUSR_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_getCursorUSR(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorSpelling_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_getCursorSpelling(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getSpellingNameRange_wrapper(value arg_ocaml, value pieceIndex_ocaml, value options_ocaml)
{
CAMLparam3(arg_ocaml, pieceIndex_ocaml, options_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int pieceIndex;
pieceIndex = Int_val(pieceIndex_ocaml);
unsigned int options;
options = Int_val(options_ocaml);
CXSourceRange result = clang_Cursor_getSpellingNameRange(arg, pieceIndex, options);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcerange(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXPrintingPolicy, cxprintingpolicy, Cxprintingpolicy_val, Val_cxprintingpolicy, custom_finalize_default, custom_compare_default, custom_hash_default)
enum CXPrintingPolicyProperty
Cxprintingpolicyproperty_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXPrintingPolicy_Indentation;
case 1: return CXPrintingPolicy_SuppressSpecifiers;
case 2: return CXPrintingPolicy_SuppressTagKeyword;
case 3: return CXPrintingPolicy_IncludeTagDefinition;
case 4: return CXPrintingPolicy_SuppressScope;
case 5: return CXPrintingPolicy_SuppressUnwrittenScope;
case 6: return CXPrintingPolicy_SuppressInitializers;
case 7: return CXPrintingPolicy_ConstantArraySizeAsWritten;
case 8: return CXPrintingPolicy_AnonymousTagLocations;
case 9: return CXPrintingPolicy_SuppressStrongLifetime;
case 10: return CXPrintingPolicy_SuppressLifetimeQualifiers;
case 11: return CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors;
case 12: return CXPrintingPolicy_Bool;
case 13: return CXPrintingPolicy_Restrict;
case 14: return CXPrintingPolicy_Alignof;
case 15: return CXPrintingPolicy_UnderscoreAlignof;
case 16: return CXPrintingPolicy_UseVoidForZeroParams;
case 17: return CXPrintingPolicy_TerseOutput;
case 18: return CXPrintingPolicy_PolishForDeclaration;
case 19: return CXPrintingPolicy_Half;
case 20: return CXPrintingPolicy_MSWChar;
case 21: return CXPrintingPolicy_IncludeNewlines;
case 22: return CXPrintingPolicy_MSVCFormatting;
case 23: return CXPrintingPolicy_ConstantsAsWritten;
case 24: return CXPrintingPolicy_SuppressImplicitBase;
case 25: return CXPrintingPolicy_FullyQualifiedName;
}
caml_failwith_fmt("invalid value for Cxprintingpolicyproperty_val: %d", Int_val(ocaml));
return CXPrintingPolicy_Indentation;
}
value
Val_cxprintingpolicyproperty(enum CXPrintingPolicyProperty v)
{
switch (v) {
case CXPrintingPolicy_Indentation: return Val_int(0);
case CXPrintingPolicy_SuppressSpecifiers: return Val_int(1);
case CXPrintingPolicy_SuppressTagKeyword: return Val_int(2);
case CXPrintingPolicy_IncludeTagDefinition: return Val_int(3);
case CXPrintingPolicy_SuppressScope: return Val_int(4);
case CXPrintingPolicy_SuppressUnwrittenScope: return Val_int(5);
case CXPrintingPolicy_SuppressInitializers: return Val_int(6);
case CXPrintingPolicy_ConstantArraySizeAsWritten: return Val_int(7);
case CXPrintingPolicy_AnonymousTagLocations: return Val_int(8);
case CXPrintingPolicy_SuppressStrongLifetime: return Val_int(9);
case CXPrintingPolicy_SuppressLifetimeQualifiers: return Val_int(10);
case CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors: return Val_int(11);
case CXPrintingPolicy_Bool: return Val_int(12);
case CXPrintingPolicy_Restrict: return Val_int(13);
case CXPrintingPolicy_Alignof: return Val_int(14);
case CXPrintingPolicy_UnderscoreAlignof: return Val_int(15);
case CXPrintingPolicy_UseVoidForZeroParams: return Val_int(16);
case CXPrintingPolicy_TerseOutput: return Val_int(17);
case CXPrintingPolicy_PolishForDeclaration: return Val_int(18);
case CXPrintingPolicy_Half: return Val_int(19);
case CXPrintingPolicy_MSWChar: return Val_int(20);
case CXPrintingPolicy_IncludeNewlines: return Val_int(21);
case CXPrintingPolicy_MSVCFormatting: return Val_int(22);
case CXPrintingPolicy_ConstantsAsWritten: return Val_int(23);
case CXPrintingPolicy_SuppressImplicitBase: return Val_int(24);
case CXPrintingPolicy_FullyQualifiedName: return Val_int(25);
}
caml_failwith_fmt("invalid value for Val_cxprintingpolicyproperty: %d", v);
return Val_int(0);
}
CAMLprim value
clang_PrintingPolicy_getProperty_wrapper(value Policy_ocaml, value Property_ocaml)
{
CAMLparam2(Policy_ocaml, Property_ocaml);
CXPrintingPolicy Policy;
Policy = Cxprintingpolicy_val(Policy_ocaml);
enum CXPrintingPolicyProperty Property;
Property = Cxprintingpolicyproperty_val(Property_ocaml);
unsigned int result = clang_PrintingPolicy_getProperty(Policy, Property);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_PrintingPolicy_setProperty_wrapper(value Policy_ocaml, value Property_ocaml, value Value_ocaml)
{
CAMLparam3(Policy_ocaml, Property_ocaml, Value_ocaml);
CXPrintingPolicy Policy;
Policy = Cxprintingpolicy_val(Policy_ocaml);
enum CXPrintingPolicyProperty Property;
Property = Cxprintingpolicyproperty_val(Property_ocaml);
unsigned int Value;
Value = Int_val(Value_ocaml);
clang_PrintingPolicy_setProperty(Policy, Property, Value);
CAMLreturn(Val_unit);
}
CAMLprim value
clang_getCursorPrintingPolicy_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXPrintingPolicy result = clang_getCursorPrintingPolicy(arg);
{
CAMLlocal1(data);
data = Val_cxprintingpolicy(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorPrettyPrinted_wrapper(value Cursor_ocaml, value Policy_ocaml)
{
CAMLparam2(Cursor_ocaml, Policy_ocaml);
CXCursor Cursor;
Cursor = Cxcursor_val(Field(Cursor_ocaml, 0));
CXPrintingPolicy Policy;
Policy = Cxprintingpolicy_val(Policy_ocaml);
CXString result = clang_getCursorPrettyPrinted(Cursor, Policy);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorDisplayName_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_getCursorDisplayName(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorReferenced_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_getCursorReferenced(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorDefinition_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_getCursorDefinition(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_isCursorDefinition_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_isCursorDefinition(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCanonicalCursor_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_getCanonicalCursor(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getObjCSelectorIndex_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
int result = clang_Cursor_getObjCSelectorIndex(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isDynamicCall_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
int result = clang_Cursor_isDynamicCall(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getReceiverType_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXType result = clang_Cursor_getReceiverType(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getObjCPropertyAttributes_wrapper(value C_ocaml, value reserved_ocaml)
{
CAMLparam2(C_ocaml, reserved_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int reserved;
reserved = Int_val(reserved_ocaml);
unsigned int result = clang_Cursor_getObjCPropertyAttributes(C, reserved);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getObjCPropertyGetterName_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXString result = clang_Cursor_getObjCPropertyGetterName(C);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getObjCPropertySetterName_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXString result = clang_Cursor_getObjCPropertySetterName(C);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getObjCDeclQualifiers_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_getObjCDeclQualifiers(C);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isObjCOptional_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isObjCOptional(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isVariadic_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_Cursor_isVariadic(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_isExternalSymbol_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXString language;
CXString definedIn;
unsigned int isGenerated;
unsigned int result = clang_Cursor_isExternalSymbol(C, &language, &definedIn, &isGenerated);
if (result) {
CAMLlocal2(ocaml_result, data);
ocaml_result = caml_alloc(1, 0);
data = caml_alloc_tuple(3);
{
CAMLlocal1(field);
field = caml_copy_string(safe_string(clang_getCString(language)));
clang_disposeString(language);
Store_field(data, 0, field);
}
{
CAMLlocal1(field);
field = caml_copy_string(safe_string(clang_getCString(definedIn)));
clang_disposeString(definedIn);
Store_field(data, 1, field);
}
{
CAMLlocal1(field);
field = Val_int(isGenerated);
Store_field(data, 2, field);
}
Store_field(ocaml_result, 0, data);
CAMLreturn(ocaml_result);
}
else {
CAMLreturn(Val_int(0));
}}
CAMLprim value
clang_Cursor_getCommentRange_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXSourceRange result = clang_Cursor_getCommentRange(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcerange(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getRawCommentText_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXString result = clang_Cursor_getRawCommentText(C);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getBriefCommentText_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXString result = clang_Cursor_getBriefCommentText(C);
{
CAMLlocal1(data);
data = Val_string_option(clang_getCString(result));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getMangling_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_Cursor_getMangling(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getCXXManglings_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXStringSet * result = clang_Cursor_getCXXManglings(arg);
{
CAMLlocal1(data);
data = caml_alloc(result->Count, 0);
CAMLlocal1(field);
for (unsigned int i = 0; i < result->Count; i++) {
field = caml_copy_string(safe_string(clang_getCString(result->Strings[i])));
clang_disposeString(result->Strings[i]);
Store_field(data, i, field);
}
clang_disposeStringSet(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Cursor_getObjCManglings_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXStringSet * result = clang_Cursor_getObjCManglings(arg);
{
CAMLlocal1(data);
data = caml_alloc(result->Count, 0);
CAMLlocal1(field);
for (unsigned int i = 0; i < result->Count; i++) {
field = caml_copy_string(safe_string(clang_getCString(result->Strings[i])));
clang_disposeString(result->Strings[i]);
Store_field(data, i, field);
}
clang_disposeStringSet(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXModule, cxmodule, Cxmodule_val, Val_cxmodule, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_Cursor_getModule_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXModule result = clang_Cursor_getModule(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxmodule(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getModuleForFile_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXFile arg2;
arg2 = Cxfile_val(Field(arg2_ocaml, 0));
CXModule result = clang_getModuleForFile(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxmodule(result));
Store_field(data, 1, arg_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_Module_getASTFile_wrapper(value Module_ocaml)
{
CAMLparam1(Module_ocaml);
CXModule Module;
Module = Cxmodule_val(Field(Module_ocaml, 0));
CXFile result = clang_Module_getASTFile(Module);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxfile(result));
Store_field(data, 1, safe_field(Module_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Module_getParent_wrapper(value Module_ocaml)
{
CAMLparam1(Module_ocaml);
CXModule Module;
Module = Cxmodule_val(Field(Module_ocaml, 0));
CXModule result = clang_Module_getParent(Module);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxmodule(result));
Store_field(data, 1, safe_field(Module_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_Module_getName_wrapper(value Module_ocaml)
{
CAMLparam1(Module_ocaml);
CXModule Module;
Module = Cxmodule_val(Field(Module_ocaml, 0));
CXString result = clang_Module_getName(Module);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Module_getFullName_wrapper(value Module_ocaml)
{
CAMLparam1(Module_ocaml);
CXModule Module;
Module = Cxmodule_val(Field(Module_ocaml, 0));
CXString result = clang_Module_getFullName(Module);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Module_isSystem_wrapper(value Module_ocaml)
{
CAMLparam1(Module_ocaml);
CXModule Module;
Module = Cxmodule_val(Field(Module_ocaml, 0));
int result = clang_Module_isSystem(Module);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Module_getNumTopLevelHeaders_wrapper(value arg_ocaml, value Module_ocaml)
{
CAMLparam2(arg_ocaml, Module_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXModule Module;
Module = Cxmodule_val(Field(Module_ocaml, 0));
unsigned int result = clang_Module_getNumTopLevelHeaders(arg, Module);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_Module_getTopLevelHeader_wrapper(value arg_ocaml, value Module_ocaml, value Index_ocaml)
{
CAMLparam3(arg_ocaml, Module_ocaml, Index_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXModule Module;
Module = Cxmodule_val(Field(Module_ocaml, 0));
unsigned int Index;
Index = Int_val(Index_ocaml);
CXFile result = clang_Module_getTopLevelHeader(arg, Module, Index);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxfile(result));
Store_field(data, 1, arg_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXConstructor_isConvertingConstructor_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXConstructor_isConvertingConstructor(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXConstructor_isCopyConstructor_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXConstructor_isCopyConstructor(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXConstructor_isDefaultConstructor_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXConstructor_isDefaultConstructor(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXConstructor_isMoveConstructor_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXConstructor_isMoveConstructor(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXField_isMutable_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXField_isMutable(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXMethod_isDefaulted_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXMethod_isDefaulted(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXMethod_isPureVirtual_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXMethod_isPureVirtual(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXMethod_isStatic_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXMethod_isStatic(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXMethod_isVirtual_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXMethod_isVirtual(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXRecord_isAbstract_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXRecord_isAbstract(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_EnumDecl_isScoped_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_EnumDecl_isScoped(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_CXXMethod_isConst_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int result = clang_CXXMethod_isConst(C);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getTemplateCursorKind_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
enum CXCursorKind result = clang_getTemplateCursorKind(C);
{
CAMLlocal1(data);
data = Val_cxcursorkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getSpecializedCursorTemplate_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXCursor result = clang_getSpecializedCursorTemplate(C);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorReferenceNameRange_wrapper(value C_ocaml, value NameFlags_ocaml, value PieceIndex_ocaml)
{
CAMLparam3(C_ocaml, NameFlags_ocaml, PieceIndex_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
unsigned int NameFlags;
NameFlags = Int_val(NameFlags_ocaml);
unsigned int PieceIndex;
PieceIndex = Int_val(PieceIndex_ocaml);
CXSourceRange result = clang_getCursorReferenceNameRange(C, NameFlags, PieceIndex);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcerange(result));
Store_field(data, 1, safe_field(C_ocaml, 1));
CAMLreturn(data);
}
}
enum CXTokenKind
Cxtokenkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXToken_Punctuation;
case 1: return CXToken_Keyword;
case 2: return CXToken_Identifier;
case 3: return CXToken_Literal;
case 4: return CXToken_Comment;
}
caml_failwith_fmt("invalid value for Cxtokenkind_val: %d", Int_val(ocaml));
return CXToken_Punctuation;
}
value
Val_cxtokenkind(enum CXTokenKind v)
{
switch (v) {
case CXToken_Punctuation: return Val_int(0);
case CXToken_Keyword: return Val_int(1);
case CXToken_Identifier: return Val_int(2);
case CXToken_Literal: return Val_int(3);
case CXToken_Comment: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_cxtokenkind: %d", v);
return Val_int(0);
}
DECLARE_OPAQUE_EX(CXToken, cxtoken, Cxtoken_val, Val_cxtoken, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getTokenKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXToken arg;
arg = Cxtoken_val(Field(arg_ocaml, 0));
CXTokenKind result = clang_getTokenKind(arg);
{
CAMLlocal1(data);
data = Val_cxtokenkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getTokenSpelling_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXToken arg2;
arg2 = Cxtoken_val(Field(arg2_ocaml, 0));
CXString result = clang_getTokenSpelling(arg, arg2);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getTokenLocation_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXToken arg2;
arg2 = Cxtoken_val(Field(arg2_ocaml, 0));
CXSourceLocation result = clang_getTokenLocation(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcelocation(result));
Store_field(data, 1, arg_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_getTokenExtent_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXTranslationUnit arg;
arg = Cxtranslationunit_val(Field(arg_ocaml, 0));
CXToken arg2;
arg2 = Cxtoken_val(Field(arg2_ocaml, 0));
CXSourceRange result = clang_getTokenExtent(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxsourcerange(result));
Store_field(data, 1, arg_ocaml);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorKindSpelling_wrapper(value Kind_ocaml)
{
CAMLparam1(Kind_ocaml);
enum CXCursorKind Kind;
Kind = Cxcursorkind_val(Kind_ocaml);
CXString result = clang_getCursorKindSpelling(Kind);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_enableStackTraces_wrapper()
{
CAMLparam0();
clang_enableStackTraces();
CAMLreturn(Val_unit);
}
enum CXCompletionChunkKind
Cxcompletionchunkkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXCompletionChunk_Optional;
case 1: return CXCompletionChunk_TypedText;
case 2: return CXCompletionChunk_Text;
case 3: return CXCompletionChunk_Placeholder;
case 4: return CXCompletionChunk_Informative;
case 5: return CXCompletionChunk_CurrentParameter;
case 6: return CXCompletionChunk_LeftParen;
case 7: return CXCompletionChunk_RightParen;
case 8: return CXCompletionChunk_LeftBracket;
case 9: return CXCompletionChunk_RightBracket;
case 10: return CXCompletionChunk_LeftBrace;
case 11: return CXCompletionChunk_RightBrace;
case 12: return CXCompletionChunk_LeftAngle;
case 13: return CXCompletionChunk_RightAngle;
case 14: return CXCompletionChunk_Comma;
case 15: return CXCompletionChunk_ResultType;
case 16: return CXCompletionChunk_Colon;
case 17: return CXCompletionChunk_SemiColon;
case 18: return CXCompletionChunk_Equal;
case 19: return CXCompletionChunk_HorizontalSpace;
case 20: return CXCompletionChunk_VerticalSpace;
}
caml_failwith_fmt("invalid value for Cxcompletionchunkkind_val: %d", Int_val(ocaml));
return CXCompletionChunk_Optional;
}
value
Val_cxcompletionchunkkind(enum CXCompletionChunkKind v)
{
switch (v) {
case CXCompletionChunk_Optional: return Val_int(0);
case CXCompletionChunk_TypedText: return Val_int(1);
case CXCompletionChunk_Text: return Val_int(2);
case CXCompletionChunk_Placeholder: return Val_int(3);
case CXCompletionChunk_Informative: return Val_int(4);
case CXCompletionChunk_CurrentParameter: return Val_int(5);
case CXCompletionChunk_LeftParen: return Val_int(6);
case CXCompletionChunk_RightParen: return Val_int(7);
case CXCompletionChunk_LeftBracket: return Val_int(8);
case CXCompletionChunk_RightBracket: return Val_int(9);
case CXCompletionChunk_LeftBrace: return Val_int(10);
case CXCompletionChunk_RightBrace: return Val_int(11);
case CXCompletionChunk_LeftAngle: return Val_int(12);
case CXCompletionChunk_RightAngle: return Val_int(13);
case CXCompletionChunk_Comma: return Val_int(14);
case CXCompletionChunk_ResultType: return Val_int(15);
case CXCompletionChunk_Colon: return Val_int(16);
case CXCompletionChunk_SemiColon: return Val_int(17);
case CXCompletionChunk_Equal: return Val_int(18);
case CXCompletionChunk_HorizontalSpace: return Val_int(19);
case CXCompletionChunk_VerticalSpace: return Val_int(20);
}
caml_failwith_fmt("invalid value for Val_cxcompletionchunkkind: %d", v);
return Val_int(0);
}
DECLARE_OPAQUE_EX(CXCompletionString, cxcompletionstring, Cxcompletionstring_val, Val_cxcompletionstring, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getCompletionChunkKind_wrapper(value completion_string_ocaml, value chunk_number_ocaml)
{
CAMLparam2(completion_string_ocaml, chunk_number_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
unsigned int chunk_number;
chunk_number = Int_val(chunk_number_ocaml);
enum CXCompletionChunkKind result = clang_getCompletionChunkKind(completion_string, chunk_number);
{
CAMLlocal1(data);
data = Val_cxcompletionchunkkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionChunkText_wrapper(value completion_string_ocaml, value chunk_number_ocaml)
{
CAMLparam2(completion_string_ocaml, chunk_number_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
unsigned int chunk_number;
chunk_number = Int_val(chunk_number_ocaml);
CXString result = clang_getCompletionChunkText(completion_string, chunk_number);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionChunkCompletionString_wrapper(value completion_string_ocaml, value chunk_number_ocaml)
{
CAMLparam2(completion_string_ocaml, chunk_number_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
unsigned int chunk_number;
chunk_number = Int_val(chunk_number_ocaml);
CXCompletionString result = clang_getCompletionChunkCompletionString(completion_string, chunk_number);
{
CAMLlocal1(data);
data = Val_cxcompletionstring(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getNumCompletionChunks_wrapper(value completion_string_ocaml)
{
CAMLparam1(completion_string_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
unsigned int result = clang_getNumCompletionChunks(completion_string);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionPriority_wrapper(value completion_string_ocaml)
{
CAMLparam1(completion_string_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
unsigned int result = clang_getCompletionPriority(completion_string);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionAvailability_wrapper(value completion_string_ocaml)
{
CAMLparam1(completion_string_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
enum CXAvailabilityKind result = clang_getCompletionAvailability(completion_string);
{
CAMLlocal1(data);
data = Val_cxavailabilitykind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionNumAnnotations_wrapper(value completion_string_ocaml)
{
CAMLparam1(completion_string_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
unsigned int result = clang_getCompletionNumAnnotations(completion_string);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionAnnotation_wrapper(value completion_string_ocaml, value annotation_number_ocaml)
{
CAMLparam2(completion_string_ocaml, annotation_number_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
unsigned int annotation_number;
annotation_number = Int_val(annotation_number_ocaml);
CXString result = clang_getCompletionAnnotation(completion_string, annotation_number);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionParent_wrapper(value completion_string_ocaml)
{
CAMLparam1(completion_string_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
CXString result = clang_getCompletionParent(completion_string, NULL);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCompletionBriefComment_wrapper(value completion_string_ocaml)
{
CAMLparam1(completion_string_ocaml);
CXCompletionString completion_string;
completion_string = Cxcompletionstring_val(completion_string_ocaml);
CXString result = clang_getCompletionBriefComment(completion_string);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getCursorCompletionString_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCompletionString result = clang_getCursorCompletionString(cursor);
{
CAMLlocal1(data);
data = Val_cxcompletionstring(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_defaultCodeCompleteOptions_wrapper()
{
CAMLparam0();
unsigned int result = clang_defaultCodeCompleteOptions();
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getClangVersion_wrapper()
{
CAMLparam0();
CXString result = clang_getClangVersion();
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_toggleCrashRecovery_wrapper(value isEnabled_ocaml)
{
CAMLparam1(isEnabled_ocaml);
unsigned int isEnabled;
isEnabled = Int_val(isEnabled_ocaml);
clang_toggleCrashRecovery(isEnabled);
CAMLreturn(Val_unit);
}
DECLARE_OPAQUE_EX(CXEvalResult, cxevalresult, Cxevalresult_val, Val_cxevalresult, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_Cursor_Evaluate_wrapper(value C_ocaml)
{
CAMLparam1(C_ocaml);
CXCursor C;
C = Cxcursor_val(Field(C_ocaml, 0));
CXEvalResult result = clang_Cursor_Evaluate(C);
{
CAMLlocal1(data);
data = Val_cxevalresult(result);
CAMLreturn(data);
}
}
CXEvalResultKind
Cxevalresultkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXEval_Int;
case 1: return CXEval_Float;
case 2: return CXEval_ObjCStrLiteral;
case 3: return CXEval_StrLiteral;
case 4: return CXEval_CFStr;
case 5: return CXEval_Other;
case 6: return CXEval_UnExposed;
}
caml_failwith_fmt("invalid value for Cxevalresultkind_val: %d", Int_val(ocaml));
return CXEval_Int;
}
value
Val_cxevalresultkind(CXEvalResultKind v)
{
switch (v) {
case CXEval_Int: return Val_int(0);
case CXEval_Float: return Val_int(1);
case CXEval_ObjCStrLiteral: return Val_int(2);
case CXEval_StrLiteral: return Val_int(3);
case CXEval_CFStr: return Val_int(4);
case CXEval_Other: return Val_int(5);
case CXEval_UnExposed: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_cxevalresultkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_EvalResult_getKind_wrapper(value E_ocaml)
{
CAMLparam1(E_ocaml);
CXEvalResult E;
E = Cxevalresult_val(E_ocaml);
CXEvalResultKind result = clang_EvalResult_getKind(E);
{
CAMLlocal1(data);
data = Val_cxevalresultkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_EvalResult_getAsInt_wrapper(value E_ocaml)
{
CAMLparam1(E_ocaml);
CXEvalResult E;
E = Cxevalresult_val(E_ocaml);
int result = clang_EvalResult_getAsInt(E);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_EvalResult_getAsLongLong_wrapper(value E_ocaml)
{
CAMLparam1(E_ocaml);
CXEvalResult E;
E = Cxevalresult_val(E_ocaml);
long long result = clang_EvalResult_getAsLongLong(E);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_EvalResult_isUnsignedInt_wrapper(value E_ocaml)
{
CAMLparam1(E_ocaml);
CXEvalResult E;
E = Cxevalresult_val(E_ocaml);
unsigned int result = clang_EvalResult_isUnsignedInt(E);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_EvalResult_getAsUnsigned_wrapper(value E_ocaml)
{
CAMLparam1(E_ocaml);
CXEvalResult E;
E = Cxevalresult_val(E_ocaml);
unsigned long long result = clang_EvalResult_getAsUnsigned(E);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_EvalResult_getAsDouble_wrapper(value E_ocaml)
{
CAMLparam1(E_ocaml);
CXEvalResult E;
E = Cxevalresult_val(E_ocaml);
double result = clang_EvalResult_getAsDouble(E);
{
CAMLlocal1(data);
data = caml_copy_double(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_EvalResult_getAsStr_wrapper(value E_ocaml)
{
CAMLparam1(E_ocaml);
CXEvalResult E;
E = Cxevalresult_val(E_ocaml);
const char * result = clang_EvalResult_getAsStr(E);
{
CAMLlocal1(data);
data = caml_copy_string(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXRemapping, cxremapping, Cxremapping_val, Val_cxremapping, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_getRemappings_wrapper(value path_ocaml)
{
CAMLparam1(path_ocaml);
const char * path;
path = String_val(path_ocaml);
CXRemapping result = clang_getRemappings(path);
{
CAMLlocal1(data);
data = Val_cxremapping(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_getRemappingsFromFileList_wrapper(value filePaths_ocaml)
{
CAMLparam1(filePaths_ocaml);
unsigned int numFiles = Wosize_val(filePaths_ocaml);
char const ** filePaths = xmalloc(numFiles * sizeof(const char *));
unsigned int i; for (i = 0; i < numFiles; i++) {
filePaths[i] = String_val(Field(filePaths_ocaml, i));
}
CXRemapping result = clang_getRemappingsFromFileList(filePaths, numFiles);
{
CAMLlocal1(data);
data = Val_cxremapping(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_remap_getNumFiles_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXRemapping arg;
arg = Cxremapping_val(arg_ocaml);
unsigned int result = clang_remap_getNumFiles(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
DECLARE_OPAQUE_EX(CXIndexAction, cxindexaction, Cxindexaction_val, Val_cxindexaction, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_IndexAction_create_wrapper(value CIdx_ocaml)
{
CAMLparam1(CIdx_ocaml);
CXIndex CIdx;
CIdx = Cxindex_val(CIdx_ocaml);
CXIndexAction result = clang_IndexAction_create(CIdx);
{
CAMLlocal1(data);
data = Val_cxindexaction(result);
CAMLreturn(data);
}
}
enum CXVisitorResult
Cxvisitorresult_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CXVisit_Break;
case 1: return CXVisit_Continue;
}
caml_failwith_fmt("invalid value for Cxvisitorresult_val: %d", Int_val(ocaml));
return CXVisit_Break;
}
value
Val_cxvisitorresult(enum CXVisitorResult v)
{
switch (v) {
case CXVisit_Break: return Val_int(0);
case CXVisit_Continue: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_cxvisitorresult: %d", v);
return Val_int(0);
}
enum CXVisitorResult
clang_Type_visitFields_visitor_callback(CXCursor arg0, CXClientData arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); result = caml_callback(f, arg0_ocaml);
{
CAMLlocal1(data);
data = Cxvisitorresult_val(result);
CAMLreturnT(enum CXVisitorResult, data);
}
}
CAMLprim value
clang_Type_visitFields_wrapper(value T_ocaml, value visitor_ocaml)
{
CAMLparam2(T_ocaml, visitor_ocaml);
CXType T;
T = Cxtype_val(Field(T_ocaml, 0));
unsigned int result = clang_Type_visitFields(T, clang_Type_visitFields_visitor_callback, (value *[]){&visitor_ocaml,&T_ocaml});
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
static value __attribute__((unused))
Val_cxversion(struct CXVersion v)
{
CAMLparam0();
CAMLlocal1(ocaml);
ocaml = caml_alloc_tuple(3);
{
CAMLlocal1(data);
data = Val_int(v.Major);
Store_field(ocaml, 0, data);
}
{
CAMLlocal1(data);
data = Val_int(v.Minor);
Store_field(ocaml, 1, data);
}
{
CAMLlocal1(data);
data = Val_int(v.Subminor);
Store_field(ocaml, 2, data);
}
CAMLreturn(ocaml);
}
static struct CXVersion __attribute__((unused))
Cxversion_val(value ocaml)
{
CAMLparam1(ocaml);
struct CXVersion v;
v.Major = Int_val(Field(ocaml, 0));v.Minor = Int_val(Field(ocaml, 1));v.Subminor = Int_val(Field(ocaml, 2));CAMLreturnT(struct CXVersion, v);
}
CAMLprim value
clang_ext_getVersion_wrapper()
{
CAMLparam0();
CXVersion result = clang_ext_getVersion();
{
CAMLlocal1(data);
data = Val_cxversion(result);
CAMLreturn(data);
}
}
static void finalize_cxint(value v) {
clang_ext_Int_dispose(*((CXInt *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(CXInt, cxint, Cxint_val, Val_cxint, finalize_cxint, custom_compare_default, custom_hash_default)
CAMLprim value
clang_equal_cxint_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
CXInt arg2;
arg2 = Cxint_val(arg2_ocaml);
_Bool result = clang_equal_cxint(arg, arg2);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_compare_cxint_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
CXInt arg2;
arg2 = Cxint_val(arg2_ocaml);
int result = clang_compare_cxint(arg, arg2);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IntegerLiteral_getValue_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXInt result = clang_ext_IntegerLiteral_getValue(arg);
{
CAMLlocal1(data);
data = Val_cxint(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_isValid_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
_Bool result = clang_ext_Int_isValid(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_toString_wrapper(value arg_ocaml, value Radix_ocaml, value isSigned_ocaml)
{
CAMLparam3(arg_ocaml, Radix_ocaml, isSigned_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
unsigned int Radix;
Radix = Int_val(Radix_ocaml);
_Bool isSigned;
isSigned = Bool_val(isSigned_ocaml);
CXString result = clang_ext_Int_toString(arg, Radix, isSigned);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_roundToDouble_wrapper(value arg_ocaml, value isSigned_ocaml)
{
CAMLparam2(arg_ocaml, isSigned_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
_Bool isSigned;
isSigned = Bool_val(isSigned_ocaml);
double result = clang_ext_Int_roundToDouble(arg, isSigned);
{
CAMLlocal1(data);
data = caml_copy_double(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_bitsToFloat_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
float result = clang_ext_Int_bitsToFloat(arg);
{
CAMLlocal1(data);
data = caml_copy_double(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getBitWidth_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
unsigned int result = clang_ext_Int_getBitWidth(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getActiveBits_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
unsigned int result = clang_ext_Int_getActiveBits(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getMinSignedBits_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
unsigned int result = clang_ext_Int_getMinSignedBits(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getBoolValue_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
_Bool result = clang_ext_Int_getBoolValue(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getZExtValue_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
int result = clang_ext_Int_getZExtValue(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getSExtValue_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
int result = clang_ext_Int_getSExtValue(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getZExtValue64_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
uint64_t result = clang_ext_Int_getZExtValue64(arg);
{
CAMLlocal1(data);
data = caml_copy_int64(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Int_getSExtValue64_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXInt arg;
arg = Cxint_val(arg_ocaml);
int64_t result = clang_ext_Int_getSExtValue64(arg);
{
CAMLlocal1(data);
data = caml_copy_int64(result);
CAMLreturn(data);
}
}
static void finalize_cxfloat(value v) {
clang_ext_Float_dispose(*((CXFloat *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(CXFloat, cxfloat, Cxfloat_val, Val_cxfloat, finalize_cxfloat, custom_compare_default, custom_hash_default)
CAMLprim value
clang_equal_cxfloat_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXFloat arg;
arg = Cxfloat_val(arg_ocaml);
CXFloat arg2;
arg2 = Cxfloat_val(arg2_ocaml);
_Bool result = clang_equal_cxfloat(arg, arg2);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_compare_cxfloat_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXFloat arg;
arg = Cxfloat_val(arg_ocaml);
CXFloat arg2;
arg2 = Cxfloat_val(arg2_ocaml);
int result = clang_compare_cxfloat(arg, arg2);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FloatingLiteral_getValue_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXFloat result = clang_ext_FloatingLiteral_getValue(arg);
{
CAMLlocal1(data);
data = Val_cxfloat(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Float_isValid_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXFloat arg;
arg = Cxfloat_val(arg_ocaml);
_Bool result = clang_ext_Float_isValid(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Float_toString_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXFloat arg;
arg = Cxfloat_val(arg_ocaml);
CXString result = clang_ext_Float_toString(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
enum clang_ext_fltSemantics
Clang_ext_fltsemantics_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_fltSemantics_IEEEhalf;
case 1: return CLANG_EXT_fltSemantics_IEEEsingle;
case 2: return CLANG_EXT_fltSemantics_IEEEdouble;
case 3: return CLANG_EXT_fltSemantics_IEEEquad;
case 4: return CLANG_EXT_fltSemantics_PPCDoubleDouble;
case 5: return CLANG_EXT_fltSemantics_x87DoubleExtended;
case 6: return CLANG_EXT_fltSemantics_Bogus;
case 7: return CLANG_EXT_fltSemantics_Invalid;
}
caml_failwith_fmt("invalid value for Clang_ext_fltsemantics_val: %d", Int_val(ocaml));
return CLANG_EXT_fltSemantics_IEEEhalf;
}
value
Val_clang_ext_fltsemantics(enum clang_ext_fltSemantics v)
{
switch (v) {
case CLANG_EXT_fltSemantics_IEEEhalf: return Val_int(0);
case CLANG_EXT_fltSemantics_IEEEsingle: return Val_int(1);
case CLANG_EXT_fltSemantics_IEEEdouble: return Val_int(2);
case CLANG_EXT_fltSemantics_IEEEquad: return Val_int(3);
case CLANG_EXT_fltSemantics_PPCDoubleDouble: return Val_int(4);
case CLANG_EXT_fltSemantics_x87DoubleExtended: return Val_int(5);
case CLANG_EXT_fltSemantics_Bogus: return Val_int(6);
case CLANG_EXT_fltSemantics_Invalid: return Val_int(7);
}
caml_failwith_fmt("invalid value for Val_clang_ext_fltsemantics: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Float_getSemantics_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXFloat arg;
arg = Cxfloat_val(arg_ocaml);
enum clang_ext_fltSemantics result = clang_ext_Float_getSemantics(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_fltsemantics(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Float_convertToFloat_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXFloat arg;
arg = Cxfloat_val(arg_ocaml);
float result = clang_ext_Float_convertToFloat(arg);
{
CAMLlocal1(data);
data = caml_copy_double(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Float_convertToDouble_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXFloat arg;
arg = Cxfloat_val(arg_ocaml);
double result = clang_ext_Float_convertToDouble(arg);
{
CAMLlocal1(data);
data = caml_copy_double(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_StringLiteral_GetString_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_ext_StringLiteral_GetString(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_StringLiteral_getBytes_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_ext_StringLiteral_getBytes(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_StringLiteral_getByteLength_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_StringLiteral_getByteLength(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_StringLiteral_getCharByteWidth_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_StringLiteral_getCharByteWidth(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_StringKind
Clang_ext_stringkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_StringKind_Ordinary;
case 1: return clang_ext_StringKind_Wide;
case 2: return clang_ext_StringKind_UTF8;
case 3: return clang_ext_StringKind_UTF16;
case 4: return clang_ext_StringKind_UTF32;
case 5: return clang_ext_StringKind_InvalidStringKind;
}
caml_failwith_fmt("invalid value for Clang_ext_stringkind_val: %d", Int_val(ocaml));
return clang_ext_StringKind_Ordinary;
}
value
Val_clang_ext_stringkind(enum clang_ext_StringKind v)
{
switch (v) {
case clang_ext_StringKind_Ordinary: return Val_int(0);
case clang_ext_StringKind_Wide: return Val_int(1);
case clang_ext_StringKind_UTF8: return Val_int(2);
case clang_ext_StringKind_UTF16: return Val_int(3);
case clang_ext_StringKind_UTF32: return Val_int(4);
case clang_ext_StringKind_InvalidStringKind: return Val_int(5);
}
caml_failwith_fmt("invalid value for Val_clang_ext_stringkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_StringLiteral_getKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_StringKind result = clang_ext_StringLiteral_getKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_stringkind(result);
CAMLreturn(data);
}
}
enum clang_ext_UnaryOperatorKind
Clang_ext_unaryoperatorkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_UNARY_OPERATOR_PostInc;
case 1: return CLANG_EXT_UNARY_OPERATOR_PostDec;
case 2: return CLANG_EXT_UNARY_OPERATOR_PreInc;
case 3: return CLANG_EXT_UNARY_OPERATOR_PreDec;
case 4: return CLANG_EXT_UNARY_OPERATOR_AddrOf;
case 5: return CLANG_EXT_UNARY_OPERATOR_Deref;
case 6: return CLANG_EXT_UNARY_OPERATOR_Plus;
case 7: return CLANG_EXT_UNARY_OPERATOR_Minus;
case 8: return CLANG_EXT_UNARY_OPERATOR_Not;
case 9: return CLANG_EXT_UNARY_OPERATOR_LNot;
case 10: return CLANG_EXT_UNARY_OPERATOR_Real;
case 11: return CLANG_EXT_UNARY_OPERATOR_Imag;
case 12: return CLANG_EXT_UNARY_OPERATOR_Extension;
case 13: return CLANG_EXT_UNARY_OPERATOR_Coawait;
case 14: return CLANG_EXT_UNARY_OPERATOR_InvalidUnaryOperator;
}
caml_failwith_fmt("invalid value for Clang_ext_unaryoperatorkind_val: %d", Int_val(ocaml));
return CLANG_EXT_UNARY_OPERATOR_PostInc;
}
value
Val_clang_ext_unaryoperatorkind(enum clang_ext_UnaryOperatorKind v)
{
switch (v) {
case CLANG_EXT_UNARY_OPERATOR_PostInc: return Val_int(0);
case CLANG_EXT_UNARY_OPERATOR_PostDec: return Val_int(1);
case CLANG_EXT_UNARY_OPERATOR_PreInc: return Val_int(2);
case CLANG_EXT_UNARY_OPERATOR_PreDec: return Val_int(3);
case CLANG_EXT_UNARY_OPERATOR_AddrOf: return Val_int(4);
case CLANG_EXT_UNARY_OPERATOR_Deref: return Val_int(5);
case CLANG_EXT_UNARY_OPERATOR_Plus: return Val_int(6);
case CLANG_EXT_UNARY_OPERATOR_Minus: return Val_int(7);
case CLANG_EXT_UNARY_OPERATOR_Not: return Val_int(8);
case CLANG_EXT_UNARY_OPERATOR_LNot: return Val_int(9);
case CLANG_EXT_UNARY_OPERATOR_Real: return Val_int(10);
case CLANG_EXT_UNARY_OPERATOR_Imag: return Val_int(11);
case CLANG_EXT_UNARY_OPERATOR_Extension: return Val_int(12);
case CLANG_EXT_UNARY_OPERATOR_Coawait: return Val_int(13);
case CLANG_EXT_UNARY_OPERATOR_InvalidUnaryOperator: return Val_int(14);
}
caml_failwith_fmt("invalid value for Val_clang_ext_unaryoperatorkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_UnaryOperator_getOpcode_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_UnaryOperatorKind result = clang_ext_UnaryOperator_getOpcode(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_unaryoperatorkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_UnaryOperator_getOpcodeSpelling_wrapper(value Kind_ocaml)
{
CAMLparam1(Kind_ocaml);
enum clang_ext_UnaryOperatorKind Kind;
Kind = Clang_ext_unaryoperatorkind_val(Kind_ocaml);
CXString result = clang_ext_UnaryOperator_getOpcodeSpelling(Kind);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
enum clang_ext_BinaryOperatorKind
Clang_ext_binaryoperatorkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_BINARY_OPERATOR_PtrMemD;
case 1: return CLANG_EXT_BINARY_OPERATOR_PtrMemI;
case 2: return CLANG_EXT_BINARY_OPERATOR_Mul;
case 3: return CLANG_EXT_BINARY_OPERATOR_Div;
case 4: return CLANG_EXT_BINARY_OPERATOR_Rem;
case 5: return CLANG_EXT_BINARY_OPERATOR_Add;
case 6: return CLANG_EXT_BINARY_OPERATOR_Sub;
case 7: return CLANG_EXT_BINARY_OPERATOR_Shl;
case 8: return CLANG_EXT_BINARY_OPERATOR_Shr;
case 9: return CLANG_EXT_BINARY_OPERATOR_Cmp;
case 10: return CLANG_EXT_BINARY_OPERATOR_LT;
case 11: return CLANG_EXT_BINARY_OPERATOR_GT;
case 12: return CLANG_EXT_BINARY_OPERATOR_LE;
case 13: return CLANG_EXT_BINARY_OPERATOR_GE;
case 14: return CLANG_EXT_BINARY_OPERATOR_EQ;
case 15: return CLANG_EXT_BINARY_OPERATOR_NE;
case 16: return CLANG_EXT_BINARY_OPERATOR_And;
case 17: return CLANG_EXT_BINARY_OPERATOR_Xor;
case 18: return CLANG_EXT_BINARY_OPERATOR_Or;
case 19: return CLANG_EXT_BINARY_OPERATOR_LAnd;
case 20: return CLANG_EXT_BINARY_OPERATOR_LOr;
case 21: return CLANG_EXT_BINARY_OPERATOR_Assign;
case 22: return CLANG_EXT_BINARY_OPERATOR_MulAssign;
case 23: return CLANG_EXT_BINARY_OPERATOR_DivAssign;
case 24: return CLANG_EXT_BINARY_OPERATOR_RemAssign;
case 25: return CLANG_EXT_BINARY_OPERATOR_AddAssign;
case 26: return CLANG_EXT_BINARY_OPERATOR_SubAssign;
case 27: return CLANG_EXT_BINARY_OPERATOR_ShlAssign;
case 28: return CLANG_EXT_BINARY_OPERATOR_ShrAssign;
case 29: return CLANG_EXT_BINARY_OPERATOR_AndAssign;
case 30: return CLANG_EXT_BINARY_OPERATOR_XorAssign;
case 31: return CLANG_EXT_BINARY_OPERATOR_OrAssign;
case 32: return CLANG_EXT_BINARY_OPERATOR_Comma;
case 33: return CLANG_EXT_BINARY_OPERATOR_InvalidBinaryOperator;
}
caml_failwith_fmt("invalid value for Clang_ext_binaryoperatorkind_val: %d", Int_val(ocaml));
return CLANG_EXT_BINARY_OPERATOR_PtrMemD;
}
value
Val_clang_ext_binaryoperatorkind(enum clang_ext_BinaryOperatorKind v)
{
switch (v) {
case CLANG_EXT_BINARY_OPERATOR_PtrMemD: return Val_int(0);
case CLANG_EXT_BINARY_OPERATOR_PtrMemI: return Val_int(1);
case CLANG_EXT_BINARY_OPERATOR_Mul: return Val_int(2);
case CLANG_EXT_BINARY_OPERATOR_Div: return Val_int(3);
case CLANG_EXT_BINARY_OPERATOR_Rem: return Val_int(4);
case CLANG_EXT_BINARY_OPERATOR_Add: return Val_int(5);
case CLANG_EXT_BINARY_OPERATOR_Sub: return Val_int(6);
case CLANG_EXT_BINARY_OPERATOR_Shl: return Val_int(7);
case CLANG_EXT_BINARY_OPERATOR_Shr: return Val_int(8);
case CLANG_EXT_BINARY_OPERATOR_Cmp: return Val_int(9);
case CLANG_EXT_BINARY_OPERATOR_LT: return Val_int(10);
case CLANG_EXT_BINARY_OPERATOR_GT: return Val_int(11);
case CLANG_EXT_BINARY_OPERATOR_LE: return Val_int(12);
case CLANG_EXT_BINARY_OPERATOR_GE: return Val_int(13);
case CLANG_EXT_BINARY_OPERATOR_EQ: return Val_int(14);
case CLANG_EXT_BINARY_OPERATOR_NE: return Val_int(15);
case CLANG_EXT_BINARY_OPERATOR_And: return Val_int(16);
case CLANG_EXT_BINARY_OPERATOR_Xor: return Val_int(17);
case CLANG_EXT_BINARY_OPERATOR_Or: return Val_int(18);
case CLANG_EXT_BINARY_OPERATOR_LAnd: return Val_int(19);
case CLANG_EXT_BINARY_OPERATOR_LOr: return Val_int(20);
case CLANG_EXT_BINARY_OPERATOR_Assign: return Val_int(21);
case CLANG_EXT_BINARY_OPERATOR_MulAssign: return Val_int(22);
case CLANG_EXT_BINARY_OPERATOR_DivAssign: return Val_int(23);
case CLANG_EXT_BINARY_OPERATOR_RemAssign: return Val_int(24);
case CLANG_EXT_BINARY_OPERATOR_AddAssign: return Val_int(25);
case CLANG_EXT_BINARY_OPERATOR_SubAssign: return Val_int(26);
case CLANG_EXT_BINARY_OPERATOR_ShlAssign: return Val_int(27);
case CLANG_EXT_BINARY_OPERATOR_ShrAssign: return Val_int(28);
case CLANG_EXT_BINARY_OPERATOR_AndAssign: return Val_int(29);
case CLANG_EXT_BINARY_OPERATOR_XorAssign: return Val_int(30);
case CLANG_EXT_BINARY_OPERATOR_OrAssign: return Val_int(31);
case CLANG_EXT_BINARY_OPERATOR_Comma: return Val_int(32);
case CLANG_EXT_BINARY_OPERATOR_InvalidBinaryOperator: return Val_int(33);
}
caml_failwith_fmt("invalid value for Val_clang_ext_binaryoperatorkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_BinaryOperator_getOpcode_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_BinaryOperatorKind result = clang_ext_BinaryOperator_getOpcode(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_binaryoperatorkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_BinaryOperator_getOpcodeSpelling_wrapper(value Kind_ocaml)
{
CAMLparam1(Kind_ocaml);
enum clang_ext_BinaryOperatorKind Kind;
Kind = Clang_ext_binaryoperatorkind_val(Kind_ocaml);
CXString result = clang_ext_BinaryOperator_getOpcodeSpelling(Kind);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ForStmt_getChildrenSet_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_ForStmt_getChildrenSet(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IfStmt_getChildrenSet_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_IfStmt_getChildrenSet(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IfStmt_getInit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_IfStmt_getInit(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IfStmt_getConditionVariable_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_IfStmt_getConditionVariable(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IfStmt_getCond_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_IfStmt_getCond(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IfStmt_getThen_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_IfStmt_getThen(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IfStmt_getElse_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_IfStmt_getElse(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SwitchStmt_getChildrenSet_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_SwitchStmt_getChildrenSet(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SwitchStmt_getInit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_SwitchStmt_getInit(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_WhileStmt_getChildrenSet_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_WhileStmt_getChildrenSet(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_ElaboratedTypeKeyword
Clang_ext_elaboratedtypekeyword_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return ETK_Struct;
case 1: return ETK_Interface;
case 2: return ETK_Union;
case 3: return ETK_Class;
case 4: return ETK_Enum;
case 5: return ETK_Typename;
case 6: return ETK_NoKeyword;
}
caml_failwith_fmt("invalid value for Clang_ext_elaboratedtypekeyword_val: %d", Int_val(ocaml));
return ETK_Struct;
}
value
Val_clang_ext_elaboratedtypekeyword(enum clang_ext_ElaboratedTypeKeyword v)
{
switch (v) {
case ETK_Struct: return Val_int(0);
case ETK_Interface: return Val_int(1);
case ETK_Union: return Val_int(2);
case ETK_Class: return Val_int(3);
case ETK_Enum: return Val_int(4);
case ETK_Typename: return Val_int(5);
case ETK_NoKeyword: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_elaboratedtypekeyword: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ElaboratedType_getKeyword_wrapper(value c_ocaml)
{
CAMLparam1(c_ocaml);
CXType c;
c = Cxtype_val(Field(c_ocaml, 0));
enum clang_ext_ElaboratedTypeKeyword result = clang_ext_ElaboratedType_getKeyword(c);
{
CAMLlocal1(data);
data = Val_clang_ext_elaboratedtypekeyword(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ElaboratedType_getKeywordSpelling_wrapper(value keyword_ocaml)
{
CAMLparam1(keyword_ocaml);
enum clang_ext_ElaboratedTypeKeyword keyword;
keyword = Clang_ext_elaboratedtypekeyword_val(keyword_ocaml);
CXString result = clang_ext_ElaboratedType_getKeywordSpelling(keyword);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_VarDecl_hasInit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_VarDecl_hasInit(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_VarDecl_isConstexpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_VarDecl_isConstexpr(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_MemberRefExpr_isArrow_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_MemberRefExpr_isArrow(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Stmt_GetClassName_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_ext_Stmt_GetClassName(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Stmt_GetClassKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
int result = clang_ext_Stmt_GetClassKind(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_CursorKind
Clang_ext_cursorkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return ECK_ImplicitCastExpr;
case 1: return ECK_BinaryConditionalOperator;
case 2: return ECK_UnaryExprOrTypeTraitExpr;
case 3: return ECK_EmptyDecl;
case 4: return ECK_LinkageSpecDecl;
case 5: return ECK_Unknown;
}
caml_failwith_fmt("invalid value for Clang_ext_cursorkind_val: %d", Int_val(ocaml));
return ECK_ImplicitCastExpr;
}
value
Val_clang_ext_cursorkind(enum clang_ext_CursorKind v)
{
switch (v) {
case ECK_ImplicitCastExpr: return Val_int(0);
case ECK_BinaryConditionalOperator: return Val_int(1);
case ECK_UnaryExprOrTypeTraitExpr: return Val_int(2);
case ECK_EmptyDecl: return Val_int(3);
case ECK_LinkageSpecDecl: return Val_int(4);
case ECK_Unknown: return Val_int(5);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cursorkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_GetCursorKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_CursorKind result = clang_ext_GetCursorKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_cursorkind(result);
CAMLreturn(data);
}
}
enum clang_ext_DeclKind
Clang_ext_declkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_DECL_InvalidDecl;
case 1: return CLANG_EXT_DECL_AccessSpec;
case 2: return CLANG_EXT_DECL_Block;
case 3: return CLANG_EXT_DECL_Captured;
case 4: return CLANG_EXT_DECL_ClassScopeFunctionSpecialization;
case 5: return CLANG_EXT_DECL_Empty;
case 6: return CLANG_EXT_DECL_Export;
case 7: return CLANG_EXT_DECL_ExternCContext;
case 8: return CLANG_EXT_DECL_FileScopeAsm;
case 9: return CLANG_EXT_DECL_Friend;
case 10: return CLANG_EXT_DECL_FriendTemplate;
case 11: return CLANG_EXT_DECL_Import;
case 12: return CLANG_EXT_DECL_LifetimeExtendedTemporary;
case 13: return CLANG_EXT_DECL_LinkageSpec;
case 14: return CLANG_EXT_DECL_Label;
case 15: return CLANG_EXT_DECL_Namespace;
case 16: return CLANG_EXT_DECL_NamespaceAlias;
case 17: return CLANG_EXT_DECL_ObjCCompatibleAlias;
case 18: return CLANG_EXT_DECL_ObjCCategory;
case 19: return CLANG_EXT_DECL_ObjCCategoryImpl;
case 20: return CLANG_EXT_DECL_ObjCImplementation;
case 21: return CLANG_EXT_DECL_ObjCInterface;
case 22: return CLANG_EXT_DECL_ObjCProtocol;
case 23: return CLANG_EXT_DECL_ObjCMethod;
case 24: return CLANG_EXT_DECL_ObjCProperty;
case 25: return CLANG_EXT_DECL_BuiltinTemplate;
case 26: return CLANG_EXT_DECL_Concept;
case 27: return CLANG_EXT_DECL_ClassTemplate;
case 28: return CLANG_EXT_DECL_FunctionTemplate;
case 29: return CLANG_EXT_DECL_TypeAliasTemplate;
case 30: return CLANG_EXT_DECL_VarTemplate;
case 31: return CLANG_EXT_DECL_TemplateTemplateParm;
case 32: return CLANG_EXT_DECL_Enum;
case 33: return CLANG_EXT_DECL_Record;
case 34: return CLANG_EXT_DECL_CXXRecord;
case 35: return CLANG_EXT_DECL_ClassTemplateSpecialization;
case 36: return CLANG_EXT_DECL_ClassTemplatePartialSpecialization;
case 37: return CLANG_EXT_DECL_TemplateTypeParm;
case 38: return CLANG_EXT_DECL_ObjCTypeParam;
case 39: return CLANG_EXT_DECL_TypeAlias;
case 40: return CLANG_EXT_DECL_Typedef;
case 41: return CLANG_EXT_DECL_UnresolvedUsingTypename;
case 42: return CLANG_EXT_DECL_Using;
case 43: return CLANG_EXT_DECL_UsingDirective;
case 44: return CLANG_EXT_DECL_UsingPack;
case 45: return CLANG_EXT_DECL_UsingShadow;
case 46: return CLANG_EXT_DECL_ConstructorUsingShadow;
case 47: return CLANG_EXT_DECL_Binding;
case 48: return CLANG_EXT_DECL_Field;
case 49: return CLANG_EXT_DECL_ObjCAtDefsField;
case 50: return CLANG_EXT_DECL_ObjCIvar;
case 51: return CLANG_EXT_DECL_Function;
case 52: return CLANG_EXT_DECL_CXXDeductionGuide;
case 53: return CLANG_EXT_DECL_CXXMethod;
case 54: return CLANG_EXT_DECL_CXXConstructor;
case 55: return CLANG_EXT_DECL_CXXConversion;
case 56: return CLANG_EXT_DECL_CXXDestructor;
case 57: return CLANG_EXT_DECL_MSProperty;
case 58: return CLANG_EXT_DECL_NonTypeTemplateParm;
case 59: return CLANG_EXT_DECL_Var;
case 60: return CLANG_EXT_DECL_Decomposition;
case 61: return CLANG_EXT_DECL_ImplicitParam;
case 62: return CLANG_EXT_DECL_OMPCapturedExpr;
case 63: return CLANG_EXT_DECL_ParmVar;
case 64: return CLANG_EXT_DECL_VarTemplateSpecialization;
case 65: return CLANG_EXT_DECL_VarTemplatePartialSpecialization;
case 66: return CLANG_EXT_DECL_EnumConstant;
case 67: return CLANG_EXT_DECL_IndirectField;
case 68: return CLANG_EXT_DECL_MSGuid;
case 69: return CLANG_EXT_DECL_OMPDeclareMapper;
case 70: return CLANG_EXT_DECL_OMPDeclareReduction;
case 71: return CLANG_EXT_DECL_UnresolvedUsingValue;
case 72: return CLANG_EXT_DECL_OMPAllocate;
case 73: return CLANG_EXT_DECL_OMPRequires;
case 74: return CLANG_EXT_DECL_OMPThreadPrivate;
case 75: return CLANG_EXT_DECL_ObjCPropertyImpl;
case 76: return CLANG_EXT_DECL_PragmaComment;
case 77: return CLANG_EXT_DECL_PragmaDetectMismatch;
case 78: return CLANG_EXT_DECL_RequiresExprBody;
case 79: return CLANG_EXT_DECL_StaticAssert;
case 80: return CLANG_EXT_DECL_TranslationUnit;
case 81: return CLANG_EXT_DECL_UnknownDecl;
}
caml_failwith_fmt("invalid value for Clang_ext_declkind_val: %d", Int_val(ocaml));
return CLANG_EXT_DECL_InvalidDecl;
}
value
Val_clang_ext_declkind(enum clang_ext_DeclKind v)
{
switch (v) {
case CLANG_EXT_DECL_InvalidDecl: return Val_int(0);
case CLANG_EXT_DECL_AccessSpec: return Val_int(1);
case CLANG_EXT_DECL_Block: return Val_int(2);
case CLANG_EXT_DECL_Captured: return Val_int(3);
case CLANG_EXT_DECL_ClassScopeFunctionSpecialization: return Val_int(4);
case CLANG_EXT_DECL_Empty: return Val_int(5);
case CLANG_EXT_DECL_Export: return Val_int(6);
case CLANG_EXT_DECL_ExternCContext: return Val_int(7);
case CLANG_EXT_DECL_FileScopeAsm: return Val_int(8);
case CLANG_EXT_DECL_Friend: return Val_int(9);
case CLANG_EXT_DECL_FriendTemplate: return Val_int(10);
case CLANG_EXT_DECL_Import: return Val_int(11);
case CLANG_EXT_DECL_LifetimeExtendedTemporary: return Val_int(12);
case CLANG_EXT_DECL_LinkageSpec: return Val_int(13);
case CLANG_EXT_DECL_Label: return Val_int(14);
case CLANG_EXT_DECL_Namespace: return Val_int(15);
case CLANG_EXT_DECL_NamespaceAlias: return Val_int(16);
case CLANG_EXT_DECL_ObjCCompatibleAlias: return Val_int(17);
case CLANG_EXT_DECL_ObjCCategory: return Val_int(18);
case CLANG_EXT_DECL_ObjCCategoryImpl: return Val_int(19);
case CLANG_EXT_DECL_ObjCImplementation: return Val_int(20);
case CLANG_EXT_DECL_ObjCInterface: return Val_int(21);
case CLANG_EXT_DECL_ObjCProtocol: return Val_int(22);
case CLANG_EXT_DECL_ObjCMethod: return Val_int(23);
case CLANG_EXT_DECL_ObjCProperty: return Val_int(24);
case CLANG_EXT_DECL_BuiltinTemplate: return Val_int(25);
case CLANG_EXT_DECL_Concept: return Val_int(26);
case CLANG_EXT_DECL_ClassTemplate: return Val_int(27);
case CLANG_EXT_DECL_FunctionTemplate: return Val_int(28);
case CLANG_EXT_DECL_TypeAliasTemplate: return Val_int(29);
case CLANG_EXT_DECL_VarTemplate: return Val_int(30);
case CLANG_EXT_DECL_TemplateTemplateParm: return Val_int(31);
case CLANG_EXT_DECL_Enum: return Val_int(32);
case CLANG_EXT_DECL_Record: return Val_int(33);
case CLANG_EXT_DECL_CXXRecord: return Val_int(34);
case CLANG_EXT_DECL_ClassTemplateSpecialization: return Val_int(35);
case CLANG_EXT_DECL_ClassTemplatePartialSpecialization: return Val_int(36);
case CLANG_EXT_DECL_TemplateTypeParm: return Val_int(37);
case CLANG_EXT_DECL_ObjCTypeParam: return Val_int(38);
case CLANG_EXT_DECL_TypeAlias: return Val_int(39);
case CLANG_EXT_DECL_Typedef: return Val_int(40);
case CLANG_EXT_DECL_UnresolvedUsingTypename: return Val_int(41);
case CLANG_EXT_DECL_Using: return Val_int(42);
case CLANG_EXT_DECL_UsingDirective: return Val_int(43);
case CLANG_EXT_DECL_UsingPack: return Val_int(44);
case CLANG_EXT_DECL_UsingShadow: return Val_int(45);
case CLANG_EXT_DECL_ConstructorUsingShadow: return Val_int(46);
case CLANG_EXT_DECL_Binding: return Val_int(47);
case CLANG_EXT_DECL_Field: return Val_int(48);
case CLANG_EXT_DECL_ObjCAtDefsField: return Val_int(49);
case CLANG_EXT_DECL_ObjCIvar: return Val_int(50);
case CLANG_EXT_DECL_Function: return Val_int(51);
case CLANG_EXT_DECL_CXXDeductionGuide: return Val_int(52);
case CLANG_EXT_DECL_CXXMethod: return Val_int(53);
case CLANG_EXT_DECL_CXXConstructor: return Val_int(54);
case CLANG_EXT_DECL_CXXConversion: return Val_int(55);
case CLANG_EXT_DECL_CXXDestructor: return Val_int(56);
case CLANG_EXT_DECL_MSProperty: return Val_int(57);
case CLANG_EXT_DECL_NonTypeTemplateParm: return Val_int(58);
case CLANG_EXT_DECL_Var: return Val_int(59);
case CLANG_EXT_DECL_Decomposition: return Val_int(60);
case CLANG_EXT_DECL_ImplicitParam: return Val_int(61);
case CLANG_EXT_DECL_OMPCapturedExpr: return Val_int(62);
case CLANG_EXT_DECL_ParmVar: return Val_int(63);
case CLANG_EXT_DECL_VarTemplateSpecialization: return Val_int(64);
case CLANG_EXT_DECL_VarTemplatePartialSpecialization: return Val_int(65);
case CLANG_EXT_DECL_EnumConstant: return Val_int(66);
case CLANG_EXT_DECL_IndirectField: return Val_int(67);
case CLANG_EXT_DECL_MSGuid: return Val_int(68);
case CLANG_EXT_DECL_OMPDeclareMapper: return Val_int(69);
case CLANG_EXT_DECL_OMPDeclareReduction: return Val_int(70);
case CLANG_EXT_DECL_UnresolvedUsingValue: return Val_int(71);
case CLANG_EXT_DECL_OMPAllocate: return Val_int(72);
case CLANG_EXT_DECL_OMPRequires: return Val_int(73);
case CLANG_EXT_DECL_OMPThreadPrivate: return Val_int(74);
case CLANG_EXT_DECL_ObjCPropertyImpl: return Val_int(75);
case CLANG_EXT_DECL_PragmaComment: return Val_int(76);
case CLANG_EXT_DECL_PragmaDetectMismatch: return Val_int(77);
case CLANG_EXT_DECL_RequiresExprBody: return Val_int(78);
case CLANG_EXT_DECL_StaticAssert: return Val_int(79);
case CLANG_EXT_DECL_TranslationUnit: return Val_int(80);
case CLANG_EXT_DECL_UnknownDecl: return Val_int(81);
}
caml_failwith_fmt("invalid value for Val_clang_ext_declkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Decl_GetKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_DeclKind result = clang_ext_Decl_GetKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_declkind(result);
CAMLreturn(data);
}
}
enum CXChildVisitResult
clang_ext_Decl_visitAttributes_visitor_callback(CXCursor arg0, CXCursor arg1, CXClientData arg2)
{
CAMLparam0();
CAMLlocal4(result, f, arg0_ocaml, arg1_ocaml);
f = *((value *) ((value **)arg2)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg2)[1], 1));arg1_ocaml = caml_alloc_tuple(2);
Store_field(arg1_ocaml, 0, Val_cxcursor(arg1));
Store_field(arg1_ocaml, 1, safe_field(*((value **)arg2)[1], 1)); result = caml_callback2(f, arg0_ocaml, arg1_ocaml);
{
CAMLlocal1(data);
data = Cxchildvisitresult_val(result);
CAMLreturnT(enum CXChildVisitResult, data);
}
}
CAMLprim value
clang_ext_Decl_visitAttributes_wrapper(value parent_ocaml, value visitor_ocaml)
{
CAMLparam2(parent_ocaml, visitor_ocaml);
CXCursor parent;
parent = Cxcursor_val(Field(parent_ocaml, 0));
unsigned int result = clang_ext_Decl_visitAttributes(parent, clang_ext_Decl_visitAttributes_visitor_callback, (value *[]){&visitor_ocaml,&parent_ocaml});
{
CAMLlocal1(data);
data = Val_not_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Decl_isImplicit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_Decl_isImplicit(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_RecordDecl_isInjectedClassName_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_RecordDecl_isInjectedClassName(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum CXChildVisitResult
clang_ext_CXXRecordDecl_visitBases_visitor_callback(CXCursor arg0, CXCursor arg1, CXClientData arg2)
{
CAMLparam0();
CAMLlocal4(result, f, arg0_ocaml, arg1_ocaml);
f = *((value *) ((value **)arg2)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg2)[1], 1));arg1_ocaml = caml_alloc_tuple(2);
Store_field(arg1_ocaml, 0, Val_cxcursor(arg1));
Store_field(arg1_ocaml, 1, safe_field(*((value **)arg2)[1], 1)); result = caml_callback2(f, arg0_ocaml, arg1_ocaml);
{
CAMLlocal1(data);
data = Cxchildvisitresult_val(result);
CAMLreturnT(enum CXChildVisitResult, data);
}
}
CAMLprim value
clang_ext_CXXRecordDecl_visitBases_wrapper(value parent_ocaml, value visitor_ocaml)
{
CAMLparam2(parent_ocaml, visitor_ocaml);
CXCursor parent;
parent = Cxcursor_val(Field(parent_ocaml, 0));
unsigned int result = clang_ext_CXXRecordDecl_visitBases(parent, clang_ext_CXXRecordDecl_visitBases_visitor_callback, (value *[]){&visitor_ocaml,&parent_ocaml});
{
CAMLlocal1(data);
data = Val_not_bool(result);
CAMLreturn(data);
}
}
enum clang_ext_StmtKind
Clang_ext_stmtkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_STMT_InvalidStmt;
case 1: return CLANG_EXT_STMT_GCCAsmStmt;
case 2: return CLANG_EXT_STMT_MSAsmStmt;
case 3: return CLANG_EXT_STMT_BreakStmt;
case 4: return CLANG_EXT_STMT_CXXCatchStmt;
case 5: return CLANG_EXT_STMT_CXXForRangeStmt;
case 6: return CLANG_EXT_STMT_CXXTryStmt;
case 7: return CLANG_EXT_STMT_CapturedStmt;
case 8: return CLANG_EXT_STMT_CompoundStmt;
case 9: return CLANG_EXT_STMT_ContinueStmt;
case 10: return CLANG_EXT_STMT_CoreturnStmt;
case 11: return CLANG_EXT_STMT_CoroutineBodyStmt;
case 12: return CLANG_EXT_STMT_DeclStmt;
case 13: return CLANG_EXT_STMT_DoStmt;
case 14: return CLANG_EXT_STMT_ForStmt;
case 15: return CLANG_EXT_STMT_GotoStmt;
case 16: return CLANG_EXT_STMT_IfStmt;
case 17: return CLANG_EXT_STMT_IndirectGotoStmt;
case 18: return CLANG_EXT_STMT_MSDependentExistsStmt;
case 19: return CLANG_EXT_STMT_NullStmt;
case 20: return CLANG_EXT_STMT_OMPAtomicDirective;
case 21: return CLANG_EXT_STMT_OMPBarrierDirective;
case 22: return CLANG_EXT_STMT_OMPCancelDirective;
case 23: return CLANG_EXT_STMT_OMPCancellationPointDirective;
case 24: return CLANG_EXT_STMT_OMPCriticalDirective;
case 25: return CLANG_EXT_STMT_OMPDepobjDirective;
case 26: return CLANG_EXT_STMT_OMPFlushDirective;
case 27: return CLANG_EXT_STMT_OMPDistributeDirective;
case 28: return CLANG_EXT_STMT_OMPDistributeParallelForDirective;
case 29: return CLANG_EXT_STMT_OMPDistributeParallelForSimdDirective;
case 30: return CLANG_EXT_STMT_OMPDistributeSimdDirective;
case 31: return CLANG_EXT_STMT_OMPForDirective;
case 32: return CLANG_EXT_STMT_OMPForSimdDirective;
case 33: return CLANG_EXT_STMT_OMPMasterTaskLoopDirective;
case 34: return CLANG_EXT_STMT_OMPMasterTaskLoopSimdDirective;
case 35: return CLANG_EXT_STMT_OMPParallelForDirective;
case 36: return CLANG_EXT_STMT_OMPParallelForSimdDirective;
case 37: return CLANG_EXT_STMT_OMPParallelMasterTaskLoopDirective;
case 38: return CLANG_EXT_STMT_OMPParallelMasterTaskLoopSimdDirective;
case 39: return CLANG_EXT_STMT_OMPSimdDirective;
case 40: return CLANG_EXT_STMT_OMPTargetParallelForSimdDirective;
case 41: return CLANG_EXT_STMT_OMPTargetSimdDirective;
case 42: return CLANG_EXT_STMT_OMPTargetTeamsDistributeDirective;
case 43: return CLANG_EXT_STMT_OMPTargetTeamsDistributeParallelForDirective;
case 44: return CLANG_EXT_STMT_OMPTargetTeamsDistributeParallelForSimdDirective;
case 45: return CLANG_EXT_STMT_OMPTargetTeamsDistributeSimdDirective;
case 46: return CLANG_EXT_STMT_OMPTaskLoopDirective;
case 47: return CLANG_EXT_STMT_OMPTaskLoopSimdDirective;
case 48: return CLANG_EXT_STMT_OMPTeamsDistributeDirective;
case 49: return CLANG_EXT_STMT_OMPTeamsDistributeParallelForDirective;
case 50: return CLANG_EXT_STMT_OMPTeamsDistributeParallelForSimdDirective;
case 51: return CLANG_EXT_STMT_OMPTeamsDistributeSimdDirective;
case 52: return CLANG_EXT_STMT_OMPMasterDirective;
case 53: return CLANG_EXT_STMT_OMPOrderedDirective;
case 54: return CLANG_EXT_STMT_OMPParallelDirective;
case 55: return CLANG_EXT_STMT_OMPParallelMasterDirective;
case 56: return CLANG_EXT_STMT_OMPParallelSectionsDirective;
case 57: return CLANG_EXT_STMT_OMPScanDirective;
case 58: return CLANG_EXT_STMT_OMPSectionDirective;
case 59: return CLANG_EXT_STMT_OMPSectionsDirective;
case 60: return CLANG_EXT_STMT_OMPSingleDirective;
case 61: return CLANG_EXT_STMT_OMPTargetDataDirective;
case 62: return CLANG_EXT_STMT_OMPTargetDirective;
case 63: return CLANG_EXT_STMT_OMPTargetEnterDataDirective;
case 64: return CLANG_EXT_STMT_OMPTargetExitDataDirective;
case 65: return CLANG_EXT_STMT_OMPTargetParallelDirective;
case 66: return CLANG_EXT_STMT_OMPTargetParallelForDirective;
case 67: return CLANG_EXT_STMT_OMPTargetTeamsDirective;
case 68: return CLANG_EXT_STMT_OMPTargetUpdateDirective;
case 69: return CLANG_EXT_STMT_OMPTaskDirective;
case 70: return CLANG_EXT_STMT_OMPTaskgroupDirective;
case 71: return CLANG_EXT_STMT_OMPTaskwaitDirective;
case 72: return CLANG_EXT_STMT_OMPTaskyieldDirective;
case 73: return CLANG_EXT_STMT_OMPTeamsDirective;
case 74: return CLANG_EXT_STMT_ObjCAtCatchStmt;
case 75: return CLANG_EXT_STMT_ObjCAtFinallyStmt;
case 76: return CLANG_EXT_STMT_ObjCAtSynchronizedStmt;
case 77: return CLANG_EXT_STMT_ObjCAtThrowStmt;
case 78: return CLANG_EXT_STMT_ObjCAtTryStmt;
case 79: return CLANG_EXT_STMT_ObjCAutoreleasePoolStmt;
case 80: return CLANG_EXT_STMT_ObjCForCollectionStmt;
case 81: return CLANG_EXT_STMT_ReturnStmt;
case 82: return CLANG_EXT_STMT_SEHExceptStmt;
case 83: return CLANG_EXT_STMT_SEHFinallyStmt;
case 84: return CLANG_EXT_STMT_SEHLeaveStmt;
case 85: return CLANG_EXT_STMT_SEHTryStmt;
case 86: return CLANG_EXT_STMT_CaseStmt;
case 87: return CLANG_EXT_STMT_DefaultStmt;
case 88: return CLANG_EXT_STMT_SwitchStmt;
case 89: return CLANG_EXT_STMT_AttributedStmt;
case 90: return CLANG_EXT_STMT_BinaryConditionalOperator;
case 91: return CLANG_EXT_STMT_ConditionalOperator;
case 92: return CLANG_EXT_STMT_AddrLabelExpr;
case 93: return CLANG_EXT_STMT_ArrayInitIndexExpr;
case 94: return CLANG_EXT_STMT_ArrayInitLoopExpr;
case 95: return CLANG_EXT_STMT_ArraySubscriptExpr;
case 96: return CLANG_EXT_STMT_ArrayTypeTraitExpr;
case 97: return CLANG_EXT_STMT_AsTypeExpr;
case 98: return CLANG_EXT_STMT_AtomicExpr;
case 99: return CLANG_EXT_STMT_BinaryOperator;
case 100: return CLANG_EXT_STMT_CompoundAssignOperator;
case 101: return CLANG_EXT_STMT_BlockExpr;
case 102: return CLANG_EXT_STMT_CXXBindTemporaryExpr;
case 103: return CLANG_EXT_STMT_CXXBoolLiteralExpr;
case 104: return CLANG_EXT_STMT_CXXConstructExpr;
case 105: return CLANG_EXT_STMT_CXXTemporaryObjectExpr;
case 106: return CLANG_EXT_STMT_CXXDefaultArgExpr;
case 107: return CLANG_EXT_STMT_CXXDefaultInitExpr;
case 108: return CLANG_EXT_STMT_CXXDeleteExpr;
case 109: return CLANG_EXT_STMT_CXXDependentScopeMemberExpr;
case 110: return CLANG_EXT_STMT_CXXFoldExpr;
case 111: return CLANG_EXT_STMT_CXXInheritedCtorInitExpr;
case 112: return CLANG_EXT_STMT_CXXNewExpr;
case 113: return CLANG_EXT_STMT_CXXNoexceptExpr;
case 114: return CLANG_EXT_STMT_CXXNullPtrLiteralExpr;
case 115: return CLANG_EXT_STMT_CXXPseudoDestructorExpr;
case 116: return CLANG_EXT_STMT_CXXRewrittenBinaryOperator;
case 117: return CLANG_EXT_STMT_CXXScalarValueInitExpr;
case 118: return CLANG_EXT_STMT_CXXStdInitializerListExpr;
case 119: return CLANG_EXT_STMT_CXXThisExpr;
case 120: return CLANG_EXT_STMT_CXXThrowExpr;
case 121: return CLANG_EXT_STMT_CXXTypeidExpr;
case 122: return CLANG_EXT_STMT_CXXUnresolvedConstructExpr;
case 123: return CLANG_EXT_STMT_CXXUuidofExpr;
case 124: return CLANG_EXT_STMT_CallExpr;
case 125: return CLANG_EXT_STMT_CUDAKernelCallExpr;
case 126: return CLANG_EXT_STMT_CXXMemberCallExpr;
case 127: return CLANG_EXT_STMT_CXXOperatorCallExpr;
case 128: return CLANG_EXT_STMT_UserDefinedLiteral;
case 129: return CLANG_EXT_STMT_BuiltinBitCastExpr;
case 130: return CLANG_EXT_STMT_CStyleCastExpr;
case 131: return CLANG_EXT_STMT_CXXFunctionalCastExpr;
case 132: return CLANG_EXT_STMT_CXXAddrspaceCastExpr;
case 133: return CLANG_EXT_STMT_CXXConstCastExpr;
case 134: return CLANG_EXT_STMT_CXXDynamicCastExpr;
case 135: return CLANG_EXT_STMT_CXXReinterpretCastExpr;
case 136: return CLANG_EXT_STMT_CXXStaticCastExpr;
case 137: return CLANG_EXT_STMT_ObjCBridgedCastExpr;
case 138: return CLANG_EXT_STMT_ImplicitCastExpr;
case 139: return CLANG_EXT_STMT_CharacterLiteral;
case 140: return CLANG_EXT_STMT_ChooseExpr;
case 141: return CLANG_EXT_STMT_CompoundLiteralExpr;
case 142: return CLANG_EXT_STMT_ConceptSpecializationExpr;
case 143: return CLANG_EXT_STMT_ConvertVectorExpr;
case 144: return CLANG_EXT_STMT_CoawaitExpr;
case 145: return CLANG_EXT_STMT_CoyieldExpr;
case 146: return CLANG_EXT_STMT_DeclRefExpr;
case 147: return CLANG_EXT_STMT_DependentCoawaitExpr;
case 148: return CLANG_EXT_STMT_DependentScopeDeclRefExpr;
case 149: return CLANG_EXT_STMT_DesignatedInitExpr;
case 150: return CLANG_EXT_STMT_DesignatedInitUpdateExpr;
case 151: return CLANG_EXT_STMT_ExpressionTraitExpr;
case 152: return CLANG_EXT_STMT_ExtVectorElementExpr;
case 153: return CLANG_EXT_STMT_FixedPointLiteral;
case 154: return CLANG_EXT_STMT_FloatingLiteral;
case 155: return CLANG_EXT_STMT_ConstantExpr;
case 156: return CLANG_EXT_STMT_ExprWithCleanups;
case 157: return CLANG_EXT_STMT_FunctionParmPackExpr;
case 158: return CLANG_EXT_STMT_GNUNullExpr;
case 159: return CLANG_EXT_STMT_GenericSelectionExpr;
case 160: return CLANG_EXT_STMT_ImaginaryLiteral;
case 161: return CLANG_EXT_STMT_ImplicitValueInitExpr;
case 162: return CLANG_EXT_STMT_InitListExpr;
case 163: return CLANG_EXT_STMT_IntegerLiteral;
case 164: return CLANG_EXT_STMT_LambdaExpr;
case 165: return CLANG_EXT_STMT_MSPropertyRefExpr;
case 166: return CLANG_EXT_STMT_MSPropertySubscriptExpr;
case 167: return CLANG_EXT_STMT_MaterializeTemporaryExpr;
case 168: return CLANG_EXT_STMT_MatrixSubscriptExpr;
case 169: return CLANG_EXT_STMT_MemberExpr;
case 170: return CLANG_EXT_STMT_NoInitExpr;
case 171: return CLANG_EXT_STMT_OMPArraySectionExpr;
case 172: return CLANG_EXT_STMT_OMPArrayShapingExpr;
case 173: return CLANG_EXT_STMT_OMPIteratorExpr;
case 174: return CLANG_EXT_STMT_ObjCArrayLiteral;
case 175: return CLANG_EXT_STMT_ObjCAvailabilityCheckExpr;
case 176: return CLANG_EXT_STMT_ObjCBoolLiteralExpr;
case 177: return CLANG_EXT_STMT_ObjCBoxedExpr;
case 178: return CLANG_EXT_STMT_ObjCDictionaryLiteral;
case 179: return CLANG_EXT_STMT_ObjCEncodeExpr;
case 180: return CLANG_EXT_STMT_ObjCIndirectCopyRestoreExpr;
case 181: return CLANG_EXT_STMT_ObjCIsaExpr;
case 182: return CLANG_EXT_STMT_ObjCIvarRefExpr;
case 183: return CLANG_EXT_STMT_ObjCMessageExpr;
case 184: return CLANG_EXT_STMT_ObjCPropertyRefExpr;
case 185: return CLANG_EXT_STMT_ObjCProtocolExpr;
case 186: return CLANG_EXT_STMT_ObjCSelectorExpr;
case 187: return CLANG_EXT_STMT_ObjCStringLiteral;
case 188: return CLANG_EXT_STMT_ObjCSubscriptRefExpr;
case 189: return CLANG_EXT_STMT_OffsetOfExpr;
case 190: return CLANG_EXT_STMT_OpaqueValueExpr;
case 191: return CLANG_EXT_STMT_UnresolvedLookupExpr;
case 192: return CLANG_EXT_STMT_UnresolvedMemberExpr;
case 193: return CLANG_EXT_STMT_PackExpansionExpr;
case 194: return CLANG_EXT_STMT_ParenExpr;
case 195: return CLANG_EXT_STMT_ParenListExpr;
case 196: return CLANG_EXT_STMT_PredefinedExpr;
case 197: return CLANG_EXT_STMT_PseudoObjectExpr;
case 198: return CLANG_EXT_STMT_RecoveryExpr;
case 199: return CLANG_EXT_STMT_RequiresExpr;
case 200: return CLANG_EXT_STMT_ShuffleVectorExpr;
case 201: return CLANG_EXT_STMT_SizeOfPackExpr;
case 202: return CLANG_EXT_STMT_SourceLocExpr;
case 203: return CLANG_EXT_STMT_StmtExpr;
case 204: return CLANG_EXT_STMT_StringLiteral;
case 205: return CLANG_EXT_STMT_SubstNonTypeTemplateParmExpr;
case 206: return CLANG_EXT_STMT_SubstNonTypeTemplateParmPackExpr;
case 207: return CLANG_EXT_STMT_TypeTraitExpr;
case 208: return CLANG_EXT_STMT_TypoExpr;
case 209: return CLANG_EXT_STMT_UnaryExprOrTypeTraitExpr;
case 210: return CLANG_EXT_STMT_UnaryOperator;
case 211: return CLANG_EXT_STMT_VAArgExpr;
case 212: return CLANG_EXT_STMT_LabelStmt;
case 213: return CLANG_EXT_STMT_WhileStmt;
case 214: return CLANG_EXT_STMT_UnknownStmt;
}
caml_failwith_fmt("invalid value for Clang_ext_stmtkind_val: %d", Int_val(ocaml));
return CLANG_EXT_STMT_InvalidStmt;
}
value
Val_clang_ext_stmtkind(enum clang_ext_StmtKind v)
{
switch (v) {
case CLANG_EXT_STMT_InvalidStmt: return Val_int(0);
case CLANG_EXT_STMT_GCCAsmStmt: return Val_int(1);
case CLANG_EXT_STMT_MSAsmStmt: return Val_int(2);
case CLANG_EXT_STMT_BreakStmt: return Val_int(3);
case CLANG_EXT_STMT_CXXCatchStmt: return Val_int(4);
case CLANG_EXT_STMT_CXXForRangeStmt: return Val_int(5);
case CLANG_EXT_STMT_CXXTryStmt: return Val_int(6);
case CLANG_EXT_STMT_CapturedStmt: return Val_int(7);
case CLANG_EXT_STMT_CompoundStmt: return Val_int(8);
case CLANG_EXT_STMT_ContinueStmt: return Val_int(9);
case CLANG_EXT_STMT_CoreturnStmt: return Val_int(10);
case CLANG_EXT_STMT_CoroutineBodyStmt: return Val_int(11);
case CLANG_EXT_STMT_DeclStmt: return Val_int(12);
case CLANG_EXT_STMT_DoStmt: return Val_int(13);
case CLANG_EXT_STMT_ForStmt: return Val_int(14);
case CLANG_EXT_STMT_GotoStmt: return Val_int(15);
case CLANG_EXT_STMT_IfStmt: return Val_int(16);
case CLANG_EXT_STMT_IndirectGotoStmt: return Val_int(17);
case CLANG_EXT_STMT_MSDependentExistsStmt: return Val_int(18);
case CLANG_EXT_STMT_NullStmt: return Val_int(19);
case CLANG_EXT_STMT_OMPAtomicDirective: return Val_int(20);
case CLANG_EXT_STMT_OMPBarrierDirective: return Val_int(21);
case CLANG_EXT_STMT_OMPCancelDirective: return Val_int(22);
case CLANG_EXT_STMT_OMPCancellationPointDirective: return Val_int(23);
case CLANG_EXT_STMT_OMPCriticalDirective: return Val_int(24);
case CLANG_EXT_STMT_OMPDepobjDirective: return Val_int(25);
case CLANG_EXT_STMT_OMPFlushDirective: return Val_int(26);
case CLANG_EXT_STMT_OMPDistributeDirective: return Val_int(27);
case CLANG_EXT_STMT_OMPDistributeParallelForDirective: return Val_int(28);
case CLANG_EXT_STMT_OMPDistributeParallelForSimdDirective: return Val_int(29);
case CLANG_EXT_STMT_OMPDistributeSimdDirective: return Val_int(30);
case CLANG_EXT_STMT_OMPForDirective: return Val_int(31);
case CLANG_EXT_STMT_OMPForSimdDirective: return Val_int(32);
case CLANG_EXT_STMT_OMPMasterTaskLoopDirective: return Val_int(33);
case CLANG_EXT_STMT_OMPMasterTaskLoopSimdDirective: return Val_int(34);
case CLANG_EXT_STMT_OMPParallelForDirective: return Val_int(35);
case CLANG_EXT_STMT_OMPParallelForSimdDirective: return Val_int(36);
case CLANG_EXT_STMT_OMPParallelMasterTaskLoopDirective: return Val_int(37);
case CLANG_EXT_STMT_OMPParallelMasterTaskLoopSimdDirective: return Val_int(38);
case CLANG_EXT_STMT_OMPSimdDirective: return Val_int(39);
case CLANG_EXT_STMT_OMPTargetParallelForSimdDirective: return Val_int(40);
case CLANG_EXT_STMT_OMPTargetSimdDirective: return Val_int(41);
case CLANG_EXT_STMT_OMPTargetTeamsDistributeDirective: return Val_int(42);
case CLANG_EXT_STMT_OMPTargetTeamsDistributeParallelForDirective: return Val_int(43);
case CLANG_EXT_STMT_OMPTargetTeamsDistributeParallelForSimdDirective: return Val_int(44);
case CLANG_EXT_STMT_OMPTargetTeamsDistributeSimdDirective: return Val_int(45);
case CLANG_EXT_STMT_OMPTaskLoopDirective: return Val_int(46);
case CLANG_EXT_STMT_OMPTaskLoopSimdDirective: return Val_int(47);
case CLANG_EXT_STMT_OMPTeamsDistributeDirective: return Val_int(48);
case CLANG_EXT_STMT_OMPTeamsDistributeParallelForDirective: return Val_int(49);
case CLANG_EXT_STMT_OMPTeamsDistributeParallelForSimdDirective: return Val_int(50);
case CLANG_EXT_STMT_OMPTeamsDistributeSimdDirective: return Val_int(51);
case CLANG_EXT_STMT_OMPMasterDirective: return Val_int(52);
case CLANG_EXT_STMT_OMPOrderedDirective: return Val_int(53);
case CLANG_EXT_STMT_OMPParallelDirective: return Val_int(54);
case CLANG_EXT_STMT_OMPParallelMasterDirective: return Val_int(55);
case CLANG_EXT_STMT_OMPParallelSectionsDirective: return Val_int(56);
case CLANG_EXT_STMT_OMPScanDirective: return Val_int(57);
case CLANG_EXT_STMT_OMPSectionDirective: return Val_int(58);
case CLANG_EXT_STMT_OMPSectionsDirective: return Val_int(59);
case CLANG_EXT_STMT_OMPSingleDirective: return Val_int(60);
case CLANG_EXT_STMT_OMPTargetDataDirective: return Val_int(61);
case CLANG_EXT_STMT_OMPTargetDirective: return Val_int(62);
case CLANG_EXT_STMT_OMPTargetEnterDataDirective: return Val_int(63);
case CLANG_EXT_STMT_OMPTargetExitDataDirective: return Val_int(64);
case CLANG_EXT_STMT_OMPTargetParallelDirective: return Val_int(65);
case CLANG_EXT_STMT_OMPTargetParallelForDirective: return Val_int(66);
case CLANG_EXT_STMT_OMPTargetTeamsDirective: return Val_int(67);
case CLANG_EXT_STMT_OMPTargetUpdateDirective: return Val_int(68);
case CLANG_EXT_STMT_OMPTaskDirective: return Val_int(69);
case CLANG_EXT_STMT_OMPTaskgroupDirective: return Val_int(70);
case CLANG_EXT_STMT_OMPTaskwaitDirective: return Val_int(71);
case CLANG_EXT_STMT_OMPTaskyieldDirective: return Val_int(72);
case CLANG_EXT_STMT_OMPTeamsDirective: return Val_int(73);
case CLANG_EXT_STMT_ObjCAtCatchStmt: return Val_int(74);
case CLANG_EXT_STMT_ObjCAtFinallyStmt: return Val_int(75);
case CLANG_EXT_STMT_ObjCAtSynchronizedStmt: return Val_int(76);
case CLANG_EXT_STMT_ObjCAtThrowStmt: return Val_int(77);
case CLANG_EXT_STMT_ObjCAtTryStmt: return Val_int(78);
case CLANG_EXT_STMT_ObjCAutoreleasePoolStmt: return Val_int(79);
case CLANG_EXT_STMT_ObjCForCollectionStmt: return Val_int(80);
case CLANG_EXT_STMT_ReturnStmt: return Val_int(81);
case CLANG_EXT_STMT_SEHExceptStmt: return Val_int(82);
case CLANG_EXT_STMT_SEHFinallyStmt: return Val_int(83);
case CLANG_EXT_STMT_SEHLeaveStmt: return Val_int(84);
case CLANG_EXT_STMT_SEHTryStmt: return Val_int(85);
case CLANG_EXT_STMT_CaseStmt: return Val_int(86);
case CLANG_EXT_STMT_DefaultStmt: return Val_int(87);
case CLANG_EXT_STMT_SwitchStmt: return Val_int(88);
case CLANG_EXT_STMT_AttributedStmt: return Val_int(89);
case CLANG_EXT_STMT_BinaryConditionalOperator: return Val_int(90);
case CLANG_EXT_STMT_ConditionalOperator: return Val_int(91);
case CLANG_EXT_STMT_AddrLabelExpr: return Val_int(92);
case CLANG_EXT_STMT_ArrayInitIndexExpr: return Val_int(93);
case CLANG_EXT_STMT_ArrayInitLoopExpr: return Val_int(94);
case CLANG_EXT_STMT_ArraySubscriptExpr: return Val_int(95);
case CLANG_EXT_STMT_ArrayTypeTraitExpr: return Val_int(96);
case CLANG_EXT_STMT_AsTypeExpr: return Val_int(97);
case CLANG_EXT_STMT_AtomicExpr: return Val_int(98);
case CLANG_EXT_STMT_BinaryOperator: return Val_int(99);
case CLANG_EXT_STMT_CompoundAssignOperator: return Val_int(100);
case CLANG_EXT_STMT_BlockExpr: return Val_int(101);
case CLANG_EXT_STMT_CXXBindTemporaryExpr: return Val_int(102);
case CLANG_EXT_STMT_CXXBoolLiteralExpr: return Val_int(103);
case CLANG_EXT_STMT_CXXConstructExpr: return Val_int(104);
case CLANG_EXT_STMT_CXXTemporaryObjectExpr: return Val_int(105);
case CLANG_EXT_STMT_CXXDefaultArgExpr: return Val_int(106);
case CLANG_EXT_STMT_CXXDefaultInitExpr: return Val_int(107);
case CLANG_EXT_STMT_CXXDeleteExpr: return Val_int(108);
case CLANG_EXT_STMT_CXXDependentScopeMemberExpr: return Val_int(109);
case CLANG_EXT_STMT_CXXFoldExpr: return Val_int(110);
case CLANG_EXT_STMT_CXXInheritedCtorInitExpr: return Val_int(111);
case CLANG_EXT_STMT_CXXNewExpr: return Val_int(112);
case CLANG_EXT_STMT_CXXNoexceptExpr: return Val_int(113);
case CLANG_EXT_STMT_CXXNullPtrLiteralExpr: return Val_int(114);
case CLANG_EXT_STMT_CXXPseudoDestructorExpr: return Val_int(115);
case CLANG_EXT_STMT_CXXRewrittenBinaryOperator: return Val_int(116);
case CLANG_EXT_STMT_CXXScalarValueInitExpr: return Val_int(117);
case CLANG_EXT_STMT_CXXStdInitializerListExpr: return Val_int(118);
case CLANG_EXT_STMT_CXXThisExpr: return Val_int(119);
case CLANG_EXT_STMT_CXXThrowExpr: return Val_int(120);
case CLANG_EXT_STMT_CXXTypeidExpr: return Val_int(121);
case CLANG_EXT_STMT_CXXUnresolvedConstructExpr: return Val_int(122);
case CLANG_EXT_STMT_CXXUuidofExpr: return Val_int(123);
case CLANG_EXT_STMT_CallExpr: return Val_int(124);
case CLANG_EXT_STMT_CUDAKernelCallExpr: return Val_int(125);
case CLANG_EXT_STMT_CXXMemberCallExpr: return Val_int(126);
case CLANG_EXT_STMT_CXXOperatorCallExpr: return Val_int(127);
case CLANG_EXT_STMT_UserDefinedLiteral: return Val_int(128);
case CLANG_EXT_STMT_BuiltinBitCastExpr: return Val_int(129);
case CLANG_EXT_STMT_CStyleCastExpr: return Val_int(130);
case CLANG_EXT_STMT_CXXFunctionalCastExpr: return Val_int(131);
case CLANG_EXT_STMT_CXXAddrspaceCastExpr: return Val_int(132);
case CLANG_EXT_STMT_CXXConstCastExpr: return Val_int(133);
case CLANG_EXT_STMT_CXXDynamicCastExpr: return Val_int(134);
case CLANG_EXT_STMT_CXXReinterpretCastExpr: return Val_int(135);
case CLANG_EXT_STMT_CXXStaticCastExpr: return Val_int(136);
case CLANG_EXT_STMT_ObjCBridgedCastExpr: return Val_int(137);
case CLANG_EXT_STMT_ImplicitCastExpr: return Val_int(138);
case CLANG_EXT_STMT_CharacterLiteral: return Val_int(139);
case CLANG_EXT_STMT_ChooseExpr: return Val_int(140);
case CLANG_EXT_STMT_CompoundLiteralExpr: return Val_int(141);
case CLANG_EXT_STMT_ConceptSpecializationExpr: return Val_int(142);
case CLANG_EXT_STMT_ConvertVectorExpr: return Val_int(143);
case CLANG_EXT_STMT_CoawaitExpr: return Val_int(144);
case CLANG_EXT_STMT_CoyieldExpr: return Val_int(145);
case CLANG_EXT_STMT_DeclRefExpr: return Val_int(146);
case CLANG_EXT_STMT_DependentCoawaitExpr: return Val_int(147);
case CLANG_EXT_STMT_DependentScopeDeclRefExpr: return Val_int(148);
case CLANG_EXT_STMT_DesignatedInitExpr: return Val_int(149);
case CLANG_EXT_STMT_DesignatedInitUpdateExpr: return Val_int(150);
case CLANG_EXT_STMT_ExpressionTraitExpr: return Val_int(151);
case CLANG_EXT_STMT_ExtVectorElementExpr: return Val_int(152);
case CLANG_EXT_STMT_FixedPointLiteral: return Val_int(153);
case CLANG_EXT_STMT_FloatingLiteral: return Val_int(154);
case CLANG_EXT_STMT_ConstantExpr: return Val_int(155);
case CLANG_EXT_STMT_ExprWithCleanups: return Val_int(156);
case CLANG_EXT_STMT_FunctionParmPackExpr: return Val_int(157);
case CLANG_EXT_STMT_GNUNullExpr: return Val_int(158);
case CLANG_EXT_STMT_GenericSelectionExpr: return Val_int(159);
case CLANG_EXT_STMT_ImaginaryLiteral: return Val_int(160);
case CLANG_EXT_STMT_ImplicitValueInitExpr: return Val_int(161);
case CLANG_EXT_STMT_InitListExpr: return Val_int(162);
case CLANG_EXT_STMT_IntegerLiteral: return Val_int(163);
case CLANG_EXT_STMT_LambdaExpr: return Val_int(164);
case CLANG_EXT_STMT_MSPropertyRefExpr: return Val_int(165);
case CLANG_EXT_STMT_MSPropertySubscriptExpr: return Val_int(166);
case CLANG_EXT_STMT_MaterializeTemporaryExpr: return Val_int(167);
case CLANG_EXT_STMT_MatrixSubscriptExpr: return Val_int(168);
case CLANG_EXT_STMT_MemberExpr: return Val_int(169);
case CLANG_EXT_STMT_NoInitExpr: return Val_int(170);
case CLANG_EXT_STMT_OMPArraySectionExpr: return Val_int(171);
case CLANG_EXT_STMT_OMPArrayShapingExpr: return Val_int(172);
case CLANG_EXT_STMT_OMPIteratorExpr: return Val_int(173);
case CLANG_EXT_STMT_ObjCArrayLiteral: return Val_int(174);
case CLANG_EXT_STMT_ObjCAvailabilityCheckExpr: return Val_int(175);
case CLANG_EXT_STMT_ObjCBoolLiteralExpr: return Val_int(176);
case CLANG_EXT_STMT_ObjCBoxedExpr: return Val_int(177);
case CLANG_EXT_STMT_ObjCDictionaryLiteral: return Val_int(178);
case CLANG_EXT_STMT_ObjCEncodeExpr: return Val_int(179);
case CLANG_EXT_STMT_ObjCIndirectCopyRestoreExpr: return Val_int(180);
case CLANG_EXT_STMT_ObjCIsaExpr: return Val_int(181);
case CLANG_EXT_STMT_ObjCIvarRefExpr: return Val_int(182);
case CLANG_EXT_STMT_ObjCMessageExpr: return Val_int(183);
case CLANG_EXT_STMT_ObjCPropertyRefExpr: return Val_int(184);
case CLANG_EXT_STMT_ObjCProtocolExpr: return Val_int(185);
case CLANG_EXT_STMT_ObjCSelectorExpr: return Val_int(186);
case CLANG_EXT_STMT_ObjCStringLiteral: return Val_int(187);
case CLANG_EXT_STMT_ObjCSubscriptRefExpr: return Val_int(188);
case CLANG_EXT_STMT_OffsetOfExpr: return Val_int(189);
case CLANG_EXT_STMT_OpaqueValueExpr: return Val_int(190);
case CLANG_EXT_STMT_UnresolvedLookupExpr: return Val_int(191);
case CLANG_EXT_STMT_UnresolvedMemberExpr: return Val_int(192);
case CLANG_EXT_STMT_PackExpansionExpr: return Val_int(193);
case CLANG_EXT_STMT_ParenExpr: return Val_int(194);
case CLANG_EXT_STMT_ParenListExpr: return Val_int(195);
case CLANG_EXT_STMT_PredefinedExpr: return Val_int(196);
case CLANG_EXT_STMT_PseudoObjectExpr: return Val_int(197);
case CLANG_EXT_STMT_RecoveryExpr: return Val_int(198);
case CLANG_EXT_STMT_RequiresExpr: return Val_int(199);
case CLANG_EXT_STMT_ShuffleVectorExpr: return Val_int(200);
case CLANG_EXT_STMT_SizeOfPackExpr: return Val_int(201);
case CLANG_EXT_STMT_SourceLocExpr: return Val_int(202);
case CLANG_EXT_STMT_StmtExpr: return Val_int(203);
case CLANG_EXT_STMT_StringLiteral: return Val_int(204);
case CLANG_EXT_STMT_SubstNonTypeTemplateParmExpr: return Val_int(205);
case CLANG_EXT_STMT_SubstNonTypeTemplateParmPackExpr: return Val_int(206);
case CLANG_EXT_STMT_TypeTraitExpr: return Val_int(207);
case CLANG_EXT_STMT_TypoExpr: return Val_int(208);
case CLANG_EXT_STMT_UnaryExprOrTypeTraitExpr: return Val_int(209);
case CLANG_EXT_STMT_UnaryOperator: return Val_int(210);
case CLANG_EXT_STMT_VAArgExpr: return Val_int(211);
case CLANG_EXT_STMT_LabelStmt: return Val_int(212);
case CLANG_EXT_STMT_WhileStmt: return Val_int(213);
case CLANG_EXT_STMT_UnknownStmt: return Val_int(214);
}
caml_failwith_fmt("invalid value for Val_clang_ext_stmtkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Stmt_GetKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_StmtKind result = clang_ext_Stmt_GetKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_stmtkind(result);
CAMLreturn(data);
}
}
enum clang_ext_TypeKind
Clang_ext_typekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_TYPE_InvalidType;
case 1: return CLANG_EXT_TYPE_Adjusted;
case 2: return CLANG_EXT_TYPE_Decayed;
case 3: return CLANG_EXT_TYPE_ConstantArray;
case 4: return CLANG_EXT_TYPE_DependentSizedArray;
case 5: return CLANG_EXT_TYPE_IncompleteArray;
case 6: return CLANG_EXT_TYPE_VariableArray;
case 7: return CLANG_EXT_TYPE_Atomic;
case 8: return CLANG_EXT_TYPE_Attributed;
case 9: return CLANG_EXT_TYPE_BlockPointer;
case 10: return CLANG_EXT_TYPE_Builtin;
case 11: return CLANG_EXT_TYPE_Complex;
case 12: return CLANG_EXT_TYPE_Decltype;
case 13: return CLANG_EXT_TYPE_Auto;
case 14: return CLANG_EXT_TYPE_DeducedTemplateSpecialization;
case 15: return CLANG_EXT_TYPE_DependentAddressSpace;
case 16: return CLANG_EXT_TYPE_DependentExtInt;
case 17: return CLANG_EXT_TYPE_DependentName;
case 18: return CLANG_EXT_TYPE_DependentSizedExtVector;
case 19: return CLANG_EXT_TYPE_DependentTemplateSpecialization;
case 20: return CLANG_EXT_TYPE_DependentVector;
case 21: return CLANG_EXT_TYPE_Elaborated;
case 22: return CLANG_EXT_TYPE_ExtInt;
case 23: return CLANG_EXT_TYPE_FunctionNoProto;
case 24: return CLANG_EXT_TYPE_FunctionProto;
case 25: return CLANG_EXT_TYPE_InjectedClassName;
case 26: return CLANG_EXT_TYPE_MacroQualified;
case 27: return CLANG_EXT_TYPE_ConstantMatrix;
case 28: return CLANG_EXT_TYPE_DependentSizedMatrix;
case 29: return CLANG_EXT_TYPE_MemberPointer;
case 30: return CLANG_EXT_TYPE_ObjCObjectPointer;
case 31: return CLANG_EXT_TYPE_ObjCObject;
case 32: return CLANG_EXT_TYPE_ObjCInterface;
case 33: return CLANG_EXT_TYPE_ObjCTypeParam;
case 34: return CLANG_EXT_TYPE_PackExpansion;
case 35: return CLANG_EXT_TYPE_Paren;
case 36: return CLANG_EXT_TYPE_Pipe;
case 37: return CLANG_EXT_TYPE_Pointer;
case 38: return CLANG_EXT_TYPE_LValueReference;
case 39: return CLANG_EXT_TYPE_RValueReference;
case 40: return CLANG_EXT_TYPE_SubstTemplateTypeParmPack;
case 41: return CLANG_EXT_TYPE_SubstTemplateTypeParm;
case 42: return CLANG_EXT_TYPE_Enum;
case 43: return CLANG_EXT_TYPE_Record;
case 44: return CLANG_EXT_TYPE_TemplateSpecialization;
case 45: return CLANG_EXT_TYPE_TemplateTypeParm;
case 46: return CLANG_EXT_TYPE_TypeOfExpr;
case 47: return CLANG_EXT_TYPE_TypeOf;
case 48: return CLANG_EXT_TYPE_Typedef;
case 49: return CLANG_EXT_TYPE_UnaryTransform;
case 50: return CLANG_EXT_TYPE_UnresolvedUsing;
case 51: return CLANG_EXT_TYPE_Vector;
case 52: return CLANG_EXT_TYPE_ExtVector;
case 53: return CLANG_EXT_TYPE_UnknownType;
}
caml_failwith_fmt("invalid value for Clang_ext_typekind_val: %d", Int_val(ocaml));
return CLANG_EXT_TYPE_InvalidType;
}
value
Val_clang_ext_typekind(enum clang_ext_TypeKind v)
{
switch (v) {
case CLANG_EXT_TYPE_InvalidType: return Val_int(0);
case CLANG_EXT_TYPE_Adjusted: return Val_int(1);
case CLANG_EXT_TYPE_Decayed: return Val_int(2);
case CLANG_EXT_TYPE_ConstantArray: return Val_int(3);
case CLANG_EXT_TYPE_DependentSizedArray: return Val_int(4);
case CLANG_EXT_TYPE_IncompleteArray: return Val_int(5);
case CLANG_EXT_TYPE_VariableArray: return Val_int(6);
case CLANG_EXT_TYPE_Atomic: return Val_int(7);
case CLANG_EXT_TYPE_Attributed: return Val_int(8);
case CLANG_EXT_TYPE_BlockPointer: return Val_int(9);
case CLANG_EXT_TYPE_Builtin: return Val_int(10);
case CLANG_EXT_TYPE_Complex: return Val_int(11);
case CLANG_EXT_TYPE_Decltype: return Val_int(12);
case CLANG_EXT_TYPE_Auto: return Val_int(13);
case CLANG_EXT_TYPE_DeducedTemplateSpecialization: return Val_int(14);
case CLANG_EXT_TYPE_DependentAddressSpace: return Val_int(15);
case CLANG_EXT_TYPE_DependentExtInt: return Val_int(16);
case CLANG_EXT_TYPE_DependentName: return Val_int(17);
case CLANG_EXT_TYPE_DependentSizedExtVector: return Val_int(18);
case CLANG_EXT_TYPE_DependentTemplateSpecialization: return Val_int(19);
case CLANG_EXT_TYPE_DependentVector: return Val_int(20);
case CLANG_EXT_TYPE_Elaborated: return Val_int(21);
case CLANG_EXT_TYPE_ExtInt: return Val_int(22);
case CLANG_EXT_TYPE_FunctionNoProto: return Val_int(23);
case CLANG_EXT_TYPE_FunctionProto: return Val_int(24);
case CLANG_EXT_TYPE_InjectedClassName: return Val_int(25);
case CLANG_EXT_TYPE_MacroQualified: return Val_int(26);
case CLANG_EXT_TYPE_ConstantMatrix: return Val_int(27);
case CLANG_EXT_TYPE_DependentSizedMatrix: return Val_int(28);
case CLANG_EXT_TYPE_MemberPointer: return Val_int(29);
case CLANG_EXT_TYPE_ObjCObjectPointer: return Val_int(30);
case CLANG_EXT_TYPE_ObjCObject: return Val_int(31);
case CLANG_EXT_TYPE_ObjCInterface: return Val_int(32);
case CLANG_EXT_TYPE_ObjCTypeParam: return Val_int(33);
case CLANG_EXT_TYPE_PackExpansion: return Val_int(34);
case CLANG_EXT_TYPE_Paren: return Val_int(35);
case CLANG_EXT_TYPE_Pipe: return Val_int(36);
case CLANG_EXT_TYPE_Pointer: return Val_int(37);
case CLANG_EXT_TYPE_LValueReference: return Val_int(38);
case CLANG_EXT_TYPE_RValueReference: return Val_int(39);
case CLANG_EXT_TYPE_SubstTemplateTypeParmPack: return Val_int(40);
case CLANG_EXT_TYPE_SubstTemplateTypeParm: return Val_int(41);
case CLANG_EXT_TYPE_Enum: return Val_int(42);
case CLANG_EXT_TYPE_Record: return Val_int(43);
case CLANG_EXT_TYPE_TemplateSpecialization: return Val_int(44);
case CLANG_EXT_TYPE_TemplateTypeParm: return Val_int(45);
case CLANG_EXT_TYPE_TypeOfExpr: return Val_int(46);
case CLANG_EXT_TYPE_TypeOf: return Val_int(47);
case CLANG_EXT_TYPE_Typedef: return Val_int(48);
case CLANG_EXT_TYPE_UnaryTransform: return Val_int(49);
case CLANG_EXT_TYPE_UnresolvedUsing: return Val_int(50);
case CLANG_EXT_TYPE_Vector: return Val_int(51);
case CLANG_EXT_TYPE_ExtVector: return Val_int(52);
case CLANG_EXT_TYPE_UnknownType: return Val_int(53);
}
caml_failwith_fmt("invalid value for Val_clang_ext_typekind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Type_GetKind_wrapper(value c_ocaml)
{
CAMLparam1(c_ocaml);
CXType c;
c = Cxtype_val(Field(c_ocaml, 0));
enum clang_ext_TypeKind result = clang_ext_Type_GetKind(c);
{
CAMLlocal1(data);
data = Val_clang_ext_typekind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_GetTypeKind_wrapper(value c_ocaml)
{
CAMLparam1(c_ocaml);
CXType c;
c = Cxtype_val(Field(c_ocaml, 0));
enum clang_ext_TypeKind result = clang_ext_GetTypeKind(c);
{
CAMLlocal1(data);
data = Val_clang_ext_typekind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_GetInnerType_wrapper(value c_ocaml)
{
CAMLparam1(c_ocaml);
CXType c;
c = Cxtype_val(Field(c_ocaml, 0));
CXType result = clang_ext_GetInnerType(c);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(c_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DeclaratorDecl_GetSizeExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_DeclaratorDecl_GetSizeExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_VariableArrayType_GetSizeExpr_wrapper(value c_ocaml)
{
CAMLparam1(c_ocaml);
CXType c;
c = Cxtype_val(Field(c_ocaml, 0));
CXCursor result = clang_ext_VariableArrayType_GetSizeExpr(c);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(c_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_CharacterKind
Clang_ext_characterkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CharacterKind_Ascii;
case 1: return clang_ext_CharacterKind_Wide;
case 2: return clang_ext_CharacterKind_UTF8;
case 3: return clang_ext_CharacterKind_UTF16;
case 4: return clang_ext_CharacterKind_UTF32;
case 5: return clang_ext_CharacterKind_InvalidCharacterKind;
}
caml_failwith_fmt("invalid value for Clang_ext_characterkind_val: %d", Int_val(ocaml));
return clang_ext_CharacterKind_Ascii;
}
value
Val_clang_ext_characterkind(enum clang_ext_CharacterKind v)
{
switch (v) {
case clang_ext_CharacterKind_Ascii: return Val_int(0);
case clang_ext_CharacterKind_Wide: return Val_int(1);
case clang_ext_CharacterKind_UTF8: return Val_int(2);
case clang_ext_CharacterKind_UTF16: return Val_int(3);
case clang_ext_CharacterKind_UTF32: return Val_int(4);
case clang_ext_CharacterKind_InvalidCharacterKind: return Val_int(5);
}
caml_failwith_fmt("invalid value for Val_clang_ext_characterkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CharacterLiteral_GetCharacterKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_CharacterKind result = clang_ext_CharacterLiteral_GetCharacterKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_characterkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CharacterLiteral_GetValue_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_CharacterLiteral_GetValue(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_UnaryExpr
Clang_ext_unaryexpr_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return UETT_SizeOf;
case 1: return UETT_AlignOf;
case 2: return UETT_VecStep;
case 3: return UETT_OpenMPRequiredSimdAlign;
case 4: return UETT_PreferredAlignOf;
}
caml_failwith_fmt("invalid value for Clang_ext_unaryexpr_val: %d", Int_val(ocaml));
return UETT_SizeOf;
}
value
Val_clang_ext_unaryexpr(enum clang_ext_UnaryExpr v)
{
switch (v) {
case UETT_SizeOf: return Val_int(0);
case UETT_AlignOf: return Val_int(1);
case UETT_VecStep: return Val_int(2);
case UETT_OpenMPRequiredSimdAlign: return Val_int(3);
case UETT_PreferredAlignOf: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_unaryexpr: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_UnaryExpr_GetKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_UnaryExpr result = clang_ext_UnaryExpr_GetKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_unaryexpr(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_UnaryExpr_isArgumentType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_UnaryExpr_isArgumentType(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
static void finalize_clang_ext_typeloc(value v) {
clang_ext_TypeLoc_dispose(*((struct clang_ext_TypeLoc *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_TypeLoc, clang_ext_typeloc, Clang_ext_typeloc_val, Val_clang_ext_typeloc, finalize_clang_ext_typeloc, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_UnaryExpr_getArgumentTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_UnaryExpr_getArgumentTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Type_getNamedType_wrapper(value CT_ocaml)
{
CAMLparam1(CT_ocaml);
CXType CT;
CT = Cxtype_val(Field(CT_ocaml, 0));
CXType result = clang_ext_Type_getNamedType(CT);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(CT_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_AttrKind
Clang_ext_attrkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_ATTR_NoAttr;
case 1: return CLANG_EXT_ATTR_AddressSpace;
case 2: return CLANG_EXT_ATTR_ArmMveStrictPolymorphism;
case 3: return CLANG_EXT_ATTR_CmseNSCall;
case 4: return CLANG_EXT_ATTR_NoDeref;
case 5: return CLANG_EXT_ATTR_ObjCGC;
case 6: return CLANG_EXT_ATTR_ObjCInertUnsafeUnretained;
case 7: return CLANG_EXT_ATTR_ObjCKindOf;
case 8: return CLANG_EXT_ATTR_OpenCLConstantAddressSpace;
case 9: return CLANG_EXT_ATTR_OpenCLGenericAddressSpace;
case 10: return CLANG_EXT_ATTR_OpenCLGlobalAddressSpace;
case 11: return CLANG_EXT_ATTR_OpenCLLocalAddressSpace;
case 12: return CLANG_EXT_ATTR_OpenCLPrivateAddressSpace;
case 13: return CLANG_EXT_ATTR_Ptr32;
case 14: return CLANG_EXT_ATTR_Ptr64;
case 15: return CLANG_EXT_ATTR_SPtr;
case 16: return CLANG_EXT_ATTR_TypeNonNull;
case 17: return CLANG_EXT_ATTR_TypeNullUnspecified;
case 18: return CLANG_EXT_ATTR_TypeNullable;
case 19: return CLANG_EXT_ATTR_UPtr;
case 20: return CLANG_EXT_ATTR_FallThrough;
case 21: return CLANG_EXT_ATTR_NoMerge;
case 22: return CLANG_EXT_ATTR_Suppress;
case 23: return CLANG_EXT_ATTR_AArch64VectorPcs;
case 24: return CLANG_EXT_ATTR_AcquireHandle;
case 25: return CLANG_EXT_ATTR_AnyX86NoCfCheck;
case 26: return CLANG_EXT_ATTR_CDecl;
case 27: return CLANG_EXT_ATTR_FastCall;
case 28: return CLANG_EXT_ATTR_IntelOclBicc;
case 29: return CLANG_EXT_ATTR_LifetimeBound;
case 30: return CLANG_EXT_ATTR_MSABI;
case 31: return CLANG_EXT_ATTR_NSReturnsRetained;
case 32: return CLANG_EXT_ATTR_ObjCOwnership;
case 33: return CLANG_EXT_ATTR_Pascal;
case 34: return CLANG_EXT_ATTR_Pcs;
case 35: return CLANG_EXT_ATTR_PreserveAll;
case 36: return CLANG_EXT_ATTR_PreserveMost;
case 37: return CLANG_EXT_ATTR_RegCall;
case 38: return CLANG_EXT_ATTR_StdCall;
case 39: return CLANG_EXT_ATTR_SwiftCall;
case 40: return CLANG_EXT_ATTR_SysVABI;
case 41: return CLANG_EXT_ATTR_ThisCall;
case 42: return CLANG_EXT_ATTR_VectorCall;
case 43: return CLANG_EXT_ATTR_SwiftContext;
case 44: return CLANG_EXT_ATTR_SwiftErrorResult;
case 45: return CLANG_EXT_ATTR_SwiftIndirectResult;
case 46: return CLANG_EXT_ATTR_Annotate;
case 47: return CLANG_EXT_ATTR_CFConsumed;
case 48: return CLANG_EXT_ATTR_CarriesDependency;
case 49: return CLANG_EXT_ATTR_NSConsumed;
case 50: return CLANG_EXT_ATTR_NonNull;
case 51: return CLANG_EXT_ATTR_OSConsumed;
case 52: return CLANG_EXT_ATTR_PassObjectSize;
case 53: return CLANG_EXT_ATTR_ReleaseHandle;
case 54: return CLANG_EXT_ATTR_UseHandle;
case 55: return CLANG_EXT_ATTR_AMDGPUFlatWorkGroupSize;
case 56: return CLANG_EXT_ATTR_AMDGPUNumSGPR;
case 57: return CLANG_EXT_ATTR_AMDGPUNumVGPR;
case 58: return CLANG_EXT_ATTR_AMDGPUWavesPerEU;
case 59: return CLANG_EXT_ATTR_ARMInterrupt;
case 60: return CLANG_EXT_ATTR_AVRInterrupt;
case 61: return CLANG_EXT_ATTR_AVRSignal;
case 62: return CLANG_EXT_ATTR_AcquireCapability;
case 63: return CLANG_EXT_ATTR_AcquiredAfter;
case 64: return CLANG_EXT_ATTR_AcquiredBefore;
case 65: return CLANG_EXT_ATTR_AlignMac68k;
case 66: return CLANG_EXT_ATTR_Aligned;
case 67: return CLANG_EXT_ATTR_AllocAlign;
case 68: return CLANG_EXT_ATTR_AllocSize;
case 69: return CLANG_EXT_ATTR_AlwaysDestroy;
case 70: return CLANG_EXT_ATTR_AlwaysInline;
case 71: return CLANG_EXT_ATTR_AnalyzerNoReturn;
case 72: return CLANG_EXT_ATTR_AnyX86Interrupt;
case 73: return CLANG_EXT_ATTR_AnyX86NoCallerSavedRegisters;
case 74: return CLANG_EXT_ATTR_ArcWeakrefUnavailable;
case 75: return CLANG_EXT_ATTR_ArgumentWithTypeTag;
case 76: return CLANG_EXT_ATTR_ArmBuiltinAlias;
case 77: return CLANG_EXT_ATTR_Artificial;
case 78: return CLANG_EXT_ATTR_AsmLabel;
case 79: return CLANG_EXT_ATTR_AssertCapability;
case 80: return CLANG_EXT_ATTR_AssertExclusiveLock;
case 81: return CLANG_EXT_ATTR_AssertSharedLock;
case 82: return CLANG_EXT_ATTR_AssumeAligned;
case 83: return CLANG_EXT_ATTR_Availability;
case 84: return CLANG_EXT_ATTR_BPFPreserveAccessIndex;
case 85: return CLANG_EXT_ATTR_Blocks;
case 86: return CLANG_EXT_ATTR_C11NoReturn;
case 87: return CLANG_EXT_ATTR_CFAuditedTransfer;
case 88: return CLANG_EXT_ATTR_CFGuard;
case 89: return CLANG_EXT_ATTR_CFICanonicalJumpTable;
case 90: return CLANG_EXT_ATTR_CFReturnsNotRetained;
case 91: return CLANG_EXT_ATTR_CFReturnsRetained;
case 92: return CLANG_EXT_ATTR_CFUnknownTransfer;
case 93: return CLANG_EXT_ATTR_CPUDispatch;
case 94: return CLANG_EXT_ATTR_CPUSpecific;
case 95: return CLANG_EXT_ATTR_CUDAConstant;
case 96: return CLANG_EXT_ATTR_CUDADevice;
case 97: return CLANG_EXT_ATTR_CUDADeviceBuiltinSurfaceType;
case 98: return CLANG_EXT_ATTR_CUDADeviceBuiltinTextureType;
case 99: return CLANG_EXT_ATTR_CUDAGlobal;
case 100: return CLANG_EXT_ATTR_CUDAHost;
case 101: return CLANG_EXT_ATTR_CUDAInvalidTarget;
case 102: return CLANG_EXT_ATTR_CUDALaunchBounds;
case 103: return CLANG_EXT_ATTR_CUDAShared;
case 104: return CLANG_EXT_ATTR_CXX11NoReturn;
case 105: return CLANG_EXT_ATTR_CallableWhen;
case 106: return CLANG_EXT_ATTR_Callback;
case 107: return CLANG_EXT_ATTR_Capability;
case 108: return CLANG_EXT_ATTR_CapturedRecord;
case 109: return CLANG_EXT_ATTR_Cleanup;
case 110: return CLANG_EXT_ATTR_CmseNSEntry;
case 111: return CLANG_EXT_ATTR_CodeSeg;
case 112: return CLANG_EXT_ATTR_Cold;
case 113: return CLANG_EXT_ATTR_Common;
case 114: return CLANG_EXT_ATTR_Const;
case 115: return CLANG_EXT_ATTR_ConstInit;
case 116: return CLANG_EXT_ATTR_Constructor;
case 117: return CLANG_EXT_ATTR_Consumable;
case 118: return CLANG_EXT_ATTR_ConsumableAutoCast;
case 119: return CLANG_EXT_ATTR_ConsumableSetOnRead;
case 120: return CLANG_EXT_ATTR_Convergent;
case 121: return CLANG_EXT_ATTR_DLLExport;
case 122: return CLANG_EXT_ATTR_DLLExportStaticLocal;
case 123: return CLANG_EXT_ATTR_DLLImport;
case 124: return CLANG_EXT_ATTR_DLLImportStaticLocal;
case 125: return CLANG_EXT_ATTR_Deprecated;
case 126: return CLANG_EXT_ATTR_Destructor;
case 127: return CLANG_EXT_ATTR_DiagnoseIf;
case 128: return CLANG_EXT_ATTR_DisableTailCalls;
case 129: return CLANG_EXT_ATTR_EmptyBases;
case 130: return CLANG_EXT_ATTR_EnableIf;
case 131: return CLANG_EXT_ATTR_EnumExtensibility;
case 132: return CLANG_EXT_ATTR_ExcludeFromExplicitInstantiation;
case 133: return CLANG_EXT_ATTR_ExclusiveTrylockFunction;
case 134: return CLANG_EXT_ATTR_ExternalSourceSymbol;
case 135: return CLANG_EXT_ATTR_Final;
case 136: return CLANG_EXT_ATTR_FlagEnum;
case 137: return CLANG_EXT_ATTR_Flatten;
case 138: return CLANG_EXT_ATTR_Format;
case 139: return CLANG_EXT_ATTR_FormatArg;
case 140: return CLANG_EXT_ATTR_GNUInline;
case 141: return CLANG_EXT_ATTR_GuardedBy;
case 142: return CLANG_EXT_ATTR_GuardedVar;
case 143: return CLANG_EXT_ATTR_Hot;
case 144: return CLANG_EXT_ATTR_IBAction;
case 145: return CLANG_EXT_ATTR_IBOutlet;
case 146: return CLANG_EXT_ATTR_IBOutletCollection;
case 147: return CLANG_EXT_ATTR_InitPriority;
case 148: return CLANG_EXT_ATTR_InternalLinkage;
case 149: return CLANG_EXT_ATTR_LTOVisibilityPublic;
case 150: return CLANG_EXT_ATTR_LayoutVersion;
case 151: return CLANG_EXT_ATTR_LockReturned;
case 152: return CLANG_EXT_ATTR_LocksExcluded;
case 153: return CLANG_EXT_ATTR_MIGServerRoutine;
case 154: return CLANG_EXT_ATTR_MSAllocator;
case 155: return CLANG_EXT_ATTR_MSInheritance;
case 156: return CLANG_EXT_ATTR_MSNoVTable;
case 157: return CLANG_EXT_ATTR_MSP430Interrupt;
case 158: return CLANG_EXT_ATTR_MSStruct;
case 159: return CLANG_EXT_ATTR_MSVtorDisp;
case 160: return CLANG_EXT_ATTR_MaxFieldAlignment;
case 161: return CLANG_EXT_ATTR_MayAlias;
case 162: return CLANG_EXT_ATTR_MicroMips;
case 163: return CLANG_EXT_ATTR_MinSize;
case 164: return CLANG_EXT_ATTR_MinVectorWidth;
case 165: return CLANG_EXT_ATTR_Mips16;
case 166: return CLANG_EXT_ATTR_MipsInterrupt;
case 167: return CLANG_EXT_ATTR_MipsLongCall;
case 168: return CLANG_EXT_ATTR_MipsShortCall;
case 169: return CLANG_EXT_ATTR_NSConsumesSelf;
case 170: return CLANG_EXT_ATTR_NSReturnsAutoreleased;
case 171: return CLANG_EXT_ATTR_NSReturnsNotRetained;
case 172: return CLANG_EXT_ATTR_Naked;
case 173: return CLANG_EXT_ATTR_NoAlias;
case 174: return CLANG_EXT_ATTR_NoCommon;
case 175: return CLANG_EXT_ATTR_NoDebug;
case 176: return CLANG_EXT_ATTR_NoDestroy;
case 177: return CLANG_EXT_ATTR_NoDuplicate;
case 178: return CLANG_EXT_ATTR_NoInline;
case 179: return CLANG_EXT_ATTR_NoInstrumentFunction;
case 180: return CLANG_EXT_ATTR_NoMicroMips;
case 181: return CLANG_EXT_ATTR_NoMips16;
case 182: return CLANG_EXT_ATTR_NoReturn;
case 183: return CLANG_EXT_ATTR_NoSanitize;
case 184: return CLANG_EXT_ATTR_NoSpeculativeLoadHardening;
case 185: return CLANG_EXT_ATTR_NoSplitStack;
case 186: return CLANG_EXT_ATTR_NoStackProtector;
case 187: return CLANG_EXT_ATTR_NoThreadSafetyAnalysis;
case 188: return CLANG_EXT_ATTR_NoThrow;
case 189: return CLANG_EXT_ATTR_NoUniqueAddress;
case 190: return CLANG_EXT_ATTR_NotTailCalled;
case 191: return CLANG_EXT_ATTR_OMPAllocateDecl;
case 192: return CLANG_EXT_ATTR_OMPCaptureNoInit;
case 193: return CLANG_EXT_ATTR_OMPDeclareTargetDecl;
case 194: return CLANG_EXT_ATTR_OMPDeclareVariant;
case 195: return CLANG_EXT_ATTR_OMPThreadPrivateDecl;
case 196: return CLANG_EXT_ATTR_OSConsumesThis;
case 197: return CLANG_EXT_ATTR_OSReturnsNotRetained;
case 198: return CLANG_EXT_ATTR_OSReturnsRetained;
case 199: return CLANG_EXT_ATTR_OSReturnsRetainedOnNonZero;
case 200: return CLANG_EXT_ATTR_OSReturnsRetainedOnZero;
case 201: return CLANG_EXT_ATTR_ObjCBridge;
case 202: return CLANG_EXT_ATTR_ObjCBridgeMutable;
case 203: return CLANG_EXT_ATTR_ObjCBridgeRelated;
case 204: return CLANG_EXT_ATTR_ObjCException;
case 205: return CLANG_EXT_ATTR_ObjCExplicitProtocolImpl;
case 206: return CLANG_EXT_ATTR_ObjCExternallyRetained;
case 207: return CLANG_EXT_ATTR_ObjCIndependentClass;
case 208: return CLANG_EXT_ATTR_ObjCMethodFamily;
case 209: return CLANG_EXT_ATTR_ObjCNSObject;
case 210: return CLANG_EXT_ATTR_ObjCPreciseLifetime;
case 211: return CLANG_EXT_ATTR_ObjCRequiresPropertyDefs;
case 212: return CLANG_EXT_ATTR_ObjCRequiresSuper;
case 213: return CLANG_EXT_ATTR_ObjCReturnsInnerPointer;
case 214: return CLANG_EXT_ATTR_ObjCRootClass;
case 215: return CLANG_EXT_ATTR_ObjCSubclassingRestricted;
case 216: return CLANG_EXT_ATTR_OpenCLIntelReqdSubGroupSize;
case 217: return CLANG_EXT_ATTR_OpenCLKernel;
case 218: return CLANG_EXT_ATTR_OpenCLUnrollHint;
case 219: return CLANG_EXT_ATTR_OptimizeNone;
case 220: return CLANG_EXT_ATTR_Override;
case 221: return CLANG_EXT_ATTR_Owner;
case 222: return CLANG_EXT_ATTR_Ownership;
case 223: return CLANG_EXT_ATTR_Packed;
case 224: return CLANG_EXT_ATTR_ParamTypestate;
case 225: return CLANG_EXT_ATTR_PatchableFunctionEntry;
case 226: return CLANG_EXT_ATTR_Pointer;
case 227: return CLANG_EXT_ATTR_PragmaClangBSSSection;
case 228: return CLANG_EXT_ATTR_PragmaClangDataSection;
case 229: return CLANG_EXT_ATTR_PragmaClangRelroSection;
case 230: return CLANG_EXT_ATTR_PragmaClangRodataSection;
case 231: return CLANG_EXT_ATTR_PragmaClangTextSection;
case 232: return CLANG_EXT_ATTR_PtGuardedBy;
case 233: return CLANG_EXT_ATTR_PtGuardedVar;
case 234: return CLANG_EXT_ATTR_Pure;
case 235: return CLANG_EXT_ATTR_RISCVInterrupt;
case 236: return CLANG_EXT_ATTR_Reinitializes;
case 237: return CLANG_EXT_ATTR_ReleaseCapability;
case 238: return CLANG_EXT_ATTR_ReqdWorkGroupSize;
case 239: return CLANG_EXT_ATTR_RequiresCapability;
case 240: return CLANG_EXT_ATTR_Restrict;
case 241: return CLANG_EXT_ATTR_ReturnTypestate;
case 242: return CLANG_EXT_ATTR_ReturnsNonNull;
case 243: return CLANG_EXT_ATTR_ReturnsTwice;
case 244: return CLANG_EXT_ATTR_SYCLKernel;
case 245: return CLANG_EXT_ATTR_ScopedLockable;
case 246: return CLANG_EXT_ATTR_Section;
case 247: return CLANG_EXT_ATTR_SelectAny;
case 248: return CLANG_EXT_ATTR_Sentinel;
case 249: return CLANG_EXT_ATTR_SetTypestate;
case 250: return CLANG_EXT_ATTR_SharedTrylockFunction;
case 251: return CLANG_EXT_ATTR_SpeculativeLoadHardening;
case 252: return CLANG_EXT_ATTR_TLSModel;
case 253: return CLANG_EXT_ATTR_Target;
case 254: return CLANG_EXT_ATTR_TestTypestate;
case 255: return CLANG_EXT_ATTR_TransparentUnion;
case 256: return CLANG_EXT_ATTR_TrivialABI;
case 257: return CLANG_EXT_ATTR_TryAcquireCapability;
case 258: return CLANG_EXT_ATTR_TypeTagForDatatype;
case 259: return CLANG_EXT_ATTR_TypeVisibility;
case 260: return CLANG_EXT_ATTR_Unavailable;
case 261: return CLANG_EXT_ATTR_Uninitialized;
case 262: return CLANG_EXT_ATTR_Unused;
case 263: return CLANG_EXT_ATTR_Used;
case 264: return CLANG_EXT_ATTR_Uuid;
case 265: return CLANG_EXT_ATTR_VecReturn;
case 266: return CLANG_EXT_ATTR_VecTypeHint;
case 267: return CLANG_EXT_ATTR_Visibility;
case 268: return CLANG_EXT_ATTR_WarnUnused;
case 269: return CLANG_EXT_ATTR_WarnUnusedResult;
case 270: return CLANG_EXT_ATTR_Weak;
case 271: return CLANG_EXT_ATTR_WeakImport;
case 272: return CLANG_EXT_ATTR_WeakRef;
case 273: return CLANG_EXT_ATTR_WebAssemblyExportName;
case 274: return CLANG_EXT_ATTR_WebAssemblyImportModule;
case 275: return CLANG_EXT_ATTR_WebAssemblyImportName;
case 276: return CLANG_EXT_ATTR_WorkGroupSizeHint;
case 277: return CLANG_EXT_ATTR_X86ForceAlignArgPointer;
case 278: return CLANG_EXT_ATTR_XRayInstrument;
case 279: return CLANG_EXT_ATTR_XRayLogArgs;
case 280: return CLANG_EXT_ATTR_AbiTag;
case 281: return CLANG_EXT_ATTR_Alias;
case 282: return CLANG_EXT_ATTR_AlignValue;
case 283: return CLANG_EXT_ATTR_IFunc;
case 284: return CLANG_EXT_ATTR_InitSeg;
case 285: return CLANG_EXT_ATTR_LoaderUninitialized;
case 286: return CLANG_EXT_ATTR_LoopHint;
case 287: return CLANG_EXT_ATTR_Mode;
case 288: return CLANG_EXT_ATTR_NoBuiltin;
case 289: return CLANG_EXT_ATTR_NoEscape;
case 290: return CLANG_EXT_ATTR_OMPCaptureKind;
case 291: return CLANG_EXT_ATTR_OMPDeclareSimdDecl;
case 292: return CLANG_EXT_ATTR_OMPReferencedVar;
case 293: return CLANG_EXT_ATTR_ObjCBoxable;
case 294: return CLANG_EXT_ATTR_ObjCClassStub;
case 295: return CLANG_EXT_ATTR_ObjCDesignatedInitializer;
case 296: return CLANG_EXT_ATTR_ObjCDirect;
case 297: return CLANG_EXT_ATTR_ObjCDirectMembers;
case 298: return CLANG_EXT_ATTR_ObjCNonLazyClass;
case 299: return CLANG_EXT_ATTR_ObjCRuntimeName;
case 300: return CLANG_EXT_ATTR_ObjCRuntimeVisible;
case 301: return CLANG_EXT_ATTR_OpenCLAccess;
case 302: return CLANG_EXT_ATTR_Overloadable;
case 303: return CLANG_EXT_ATTR_RenderScriptKernel;
case 304: return CLANG_EXT_ATTR_Thread;
}
caml_failwith_fmt("invalid value for Clang_ext_attrkind_val: %d", Int_val(ocaml));
return CLANG_EXT_ATTR_NoAttr;
}
value
Val_clang_ext_attrkind(enum clang_ext_AttrKind v)
{
switch (v) {
case CLANG_EXT_ATTR_NoAttr: return Val_int(0);
case CLANG_EXT_ATTR_AddressSpace: return Val_int(1);
case CLANG_EXT_ATTR_ArmMveStrictPolymorphism: return Val_int(2);
case CLANG_EXT_ATTR_CmseNSCall: return Val_int(3);
case CLANG_EXT_ATTR_NoDeref: return Val_int(4);
case CLANG_EXT_ATTR_ObjCGC: return Val_int(5);
case CLANG_EXT_ATTR_ObjCInertUnsafeUnretained: return Val_int(6);
case CLANG_EXT_ATTR_ObjCKindOf: return Val_int(7);
case CLANG_EXT_ATTR_OpenCLConstantAddressSpace: return Val_int(8);
case CLANG_EXT_ATTR_OpenCLGenericAddressSpace: return Val_int(9);
case CLANG_EXT_ATTR_OpenCLGlobalAddressSpace: return Val_int(10);
case CLANG_EXT_ATTR_OpenCLLocalAddressSpace: return Val_int(11);
case CLANG_EXT_ATTR_OpenCLPrivateAddressSpace: return Val_int(12);
case CLANG_EXT_ATTR_Ptr32: return Val_int(13);
case CLANG_EXT_ATTR_Ptr64: return Val_int(14);
case CLANG_EXT_ATTR_SPtr: return Val_int(15);
case CLANG_EXT_ATTR_TypeNonNull: return Val_int(16);
case CLANG_EXT_ATTR_TypeNullUnspecified: return Val_int(17);
case CLANG_EXT_ATTR_TypeNullable: return Val_int(18);
case CLANG_EXT_ATTR_UPtr: return Val_int(19);
case CLANG_EXT_ATTR_FallThrough: return Val_int(20);
case CLANG_EXT_ATTR_NoMerge: return Val_int(21);
case CLANG_EXT_ATTR_Suppress: return Val_int(22);
case CLANG_EXT_ATTR_AArch64VectorPcs: return Val_int(23);
case CLANG_EXT_ATTR_AcquireHandle: return Val_int(24);
case CLANG_EXT_ATTR_AnyX86NoCfCheck: return Val_int(25);
case CLANG_EXT_ATTR_CDecl: return Val_int(26);
case CLANG_EXT_ATTR_FastCall: return Val_int(27);
case CLANG_EXT_ATTR_IntelOclBicc: return Val_int(28);
case CLANG_EXT_ATTR_LifetimeBound: return Val_int(29);
case CLANG_EXT_ATTR_MSABI: return Val_int(30);
case CLANG_EXT_ATTR_NSReturnsRetained: return Val_int(31);
case CLANG_EXT_ATTR_ObjCOwnership: return Val_int(32);
case CLANG_EXT_ATTR_Pascal: return Val_int(33);
case CLANG_EXT_ATTR_Pcs: return Val_int(34);
case CLANG_EXT_ATTR_PreserveAll: return Val_int(35);
case CLANG_EXT_ATTR_PreserveMost: return Val_int(36);
case CLANG_EXT_ATTR_RegCall: return Val_int(37);
case CLANG_EXT_ATTR_StdCall: return Val_int(38);
case CLANG_EXT_ATTR_SwiftCall: return Val_int(39);
case CLANG_EXT_ATTR_SysVABI: return Val_int(40);
case CLANG_EXT_ATTR_ThisCall: return Val_int(41);
case CLANG_EXT_ATTR_VectorCall: return Val_int(42);
case CLANG_EXT_ATTR_SwiftContext: return Val_int(43);
case CLANG_EXT_ATTR_SwiftErrorResult: return Val_int(44);
case CLANG_EXT_ATTR_SwiftIndirectResult: return Val_int(45);
case CLANG_EXT_ATTR_Annotate: return Val_int(46);
case CLANG_EXT_ATTR_CFConsumed: return Val_int(47);
case CLANG_EXT_ATTR_CarriesDependency: return Val_int(48);
case CLANG_EXT_ATTR_NSConsumed: return Val_int(49);
case CLANG_EXT_ATTR_NonNull: return Val_int(50);
case CLANG_EXT_ATTR_OSConsumed: return Val_int(51);
case CLANG_EXT_ATTR_PassObjectSize: return Val_int(52);
case CLANG_EXT_ATTR_ReleaseHandle: return Val_int(53);
case CLANG_EXT_ATTR_UseHandle: return Val_int(54);
case CLANG_EXT_ATTR_AMDGPUFlatWorkGroupSize: return Val_int(55);
case CLANG_EXT_ATTR_AMDGPUNumSGPR: return Val_int(56);
case CLANG_EXT_ATTR_AMDGPUNumVGPR: return Val_int(57);
case CLANG_EXT_ATTR_AMDGPUWavesPerEU: return Val_int(58);
case CLANG_EXT_ATTR_ARMInterrupt: return Val_int(59);
case CLANG_EXT_ATTR_AVRInterrupt: return Val_int(60);
case CLANG_EXT_ATTR_AVRSignal: return Val_int(61);
case CLANG_EXT_ATTR_AcquireCapability: return Val_int(62);
case CLANG_EXT_ATTR_AcquiredAfter: return Val_int(63);
case CLANG_EXT_ATTR_AcquiredBefore: return Val_int(64);
case CLANG_EXT_ATTR_AlignMac68k: return Val_int(65);
case CLANG_EXT_ATTR_Aligned: return Val_int(66);
case CLANG_EXT_ATTR_AllocAlign: return Val_int(67);
case CLANG_EXT_ATTR_AllocSize: return Val_int(68);
case CLANG_EXT_ATTR_AlwaysDestroy: return Val_int(69);
case CLANG_EXT_ATTR_AlwaysInline: return Val_int(70);
case CLANG_EXT_ATTR_AnalyzerNoReturn: return Val_int(71);
case CLANG_EXT_ATTR_AnyX86Interrupt: return Val_int(72);
case CLANG_EXT_ATTR_AnyX86NoCallerSavedRegisters: return Val_int(73);
case CLANG_EXT_ATTR_ArcWeakrefUnavailable: return Val_int(74);
case CLANG_EXT_ATTR_ArgumentWithTypeTag: return Val_int(75);
case CLANG_EXT_ATTR_ArmBuiltinAlias: return Val_int(76);
case CLANG_EXT_ATTR_Artificial: return Val_int(77);
case CLANG_EXT_ATTR_AsmLabel: return Val_int(78);
case CLANG_EXT_ATTR_AssertCapability: return Val_int(79);
case CLANG_EXT_ATTR_AssertExclusiveLock: return Val_int(80);
case CLANG_EXT_ATTR_AssertSharedLock: return Val_int(81);
case CLANG_EXT_ATTR_AssumeAligned: return Val_int(82);
case CLANG_EXT_ATTR_Availability: return Val_int(83);
case CLANG_EXT_ATTR_BPFPreserveAccessIndex: return Val_int(84);
case CLANG_EXT_ATTR_Blocks: return Val_int(85);
case CLANG_EXT_ATTR_C11NoReturn: return Val_int(86);
case CLANG_EXT_ATTR_CFAuditedTransfer: return Val_int(87);
case CLANG_EXT_ATTR_CFGuard: return Val_int(88);
case CLANG_EXT_ATTR_CFICanonicalJumpTable: return Val_int(89);
case CLANG_EXT_ATTR_CFReturnsNotRetained: return Val_int(90);
case CLANG_EXT_ATTR_CFReturnsRetained: return Val_int(91);
case CLANG_EXT_ATTR_CFUnknownTransfer: return Val_int(92);
case CLANG_EXT_ATTR_CPUDispatch: return Val_int(93);
case CLANG_EXT_ATTR_CPUSpecific: return Val_int(94);
case CLANG_EXT_ATTR_CUDAConstant: return Val_int(95);
case CLANG_EXT_ATTR_CUDADevice: return Val_int(96);
case CLANG_EXT_ATTR_CUDADeviceBuiltinSurfaceType: return Val_int(97);
case CLANG_EXT_ATTR_CUDADeviceBuiltinTextureType: return Val_int(98);
case CLANG_EXT_ATTR_CUDAGlobal: return Val_int(99);
case CLANG_EXT_ATTR_CUDAHost: return Val_int(100);
case CLANG_EXT_ATTR_CUDAInvalidTarget: return Val_int(101);
case CLANG_EXT_ATTR_CUDALaunchBounds: return Val_int(102);
case CLANG_EXT_ATTR_CUDAShared: return Val_int(103);
case CLANG_EXT_ATTR_CXX11NoReturn: return Val_int(104);
case CLANG_EXT_ATTR_CallableWhen: return Val_int(105);
case CLANG_EXT_ATTR_Callback: return Val_int(106);
case CLANG_EXT_ATTR_Capability: return Val_int(107);
case CLANG_EXT_ATTR_CapturedRecord: return Val_int(108);
case CLANG_EXT_ATTR_Cleanup: return Val_int(109);
case CLANG_EXT_ATTR_CmseNSEntry: return Val_int(110);
case CLANG_EXT_ATTR_CodeSeg: return Val_int(111);
case CLANG_EXT_ATTR_Cold: return Val_int(112);
case CLANG_EXT_ATTR_Common: return Val_int(113);
case CLANG_EXT_ATTR_Const: return Val_int(114);
case CLANG_EXT_ATTR_ConstInit: return Val_int(115);
case CLANG_EXT_ATTR_Constructor: return Val_int(116);
case CLANG_EXT_ATTR_Consumable: return Val_int(117);
case CLANG_EXT_ATTR_ConsumableAutoCast: return Val_int(118);
case CLANG_EXT_ATTR_ConsumableSetOnRead: return Val_int(119);
case CLANG_EXT_ATTR_Convergent: return Val_int(120);
case CLANG_EXT_ATTR_DLLExport: return Val_int(121);
case CLANG_EXT_ATTR_DLLExportStaticLocal: return Val_int(122);
case CLANG_EXT_ATTR_DLLImport: return Val_int(123);
case CLANG_EXT_ATTR_DLLImportStaticLocal: return Val_int(124);
case CLANG_EXT_ATTR_Deprecated: return Val_int(125);
case CLANG_EXT_ATTR_Destructor: return Val_int(126);
case CLANG_EXT_ATTR_DiagnoseIf: return Val_int(127);
case CLANG_EXT_ATTR_DisableTailCalls: return Val_int(128);
case CLANG_EXT_ATTR_EmptyBases: return Val_int(129);
case CLANG_EXT_ATTR_EnableIf: return Val_int(130);
case CLANG_EXT_ATTR_EnumExtensibility: return Val_int(131);
case CLANG_EXT_ATTR_ExcludeFromExplicitInstantiation: return Val_int(132);
case CLANG_EXT_ATTR_ExclusiveTrylockFunction: return Val_int(133);
case CLANG_EXT_ATTR_ExternalSourceSymbol: return Val_int(134);
case CLANG_EXT_ATTR_Final: return Val_int(135);
case CLANG_EXT_ATTR_FlagEnum: return Val_int(136);
case CLANG_EXT_ATTR_Flatten: return Val_int(137);
case CLANG_EXT_ATTR_Format: return Val_int(138);
case CLANG_EXT_ATTR_FormatArg: return Val_int(139);
case CLANG_EXT_ATTR_GNUInline: return Val_int(140);
case CLANG_EXT_ATTR_GuardedBy: return Val_int(141);
case CLANG_EXT_ATTR_GuardedVar: return Val_int(142);
case CLANG_EXT_ATTR_Hot: return Val_int(143);
case CLANG_EXT_ATTR_IBAction: return Val_int(144);
case CLANG_EXT_ATTR_IBOutlet: return Val_int(145);
case CLANG_EXT_ATTR_IBOutletCollection: return Val_int(146);
case CLANG_EXT_ATTR_InitPriority: return Val_int(147);
case CLANG_EXT_ATTR_InternalLinkage: return Val_int(148);
case CLANG_EXT_ATTR_LTOVisibilityPublic: return Val_int(149);
case CLANG_EXT_ATTR_LayoutVersion: return Val_int(150);
case CLANG_EXT_ATTR_LockReturned: return Val_int(151);
case CLANG_EXT_ATTR_LocksExcluded: return Val_int(152);
case CLANG_EXT_ATTR_MIGServerRoutine: return Val_int(153);
case CLANG_EXT_ATTR_MSAllocator: return Val_int(154);
case CLANG_EXT_ATTR_MSInheritance: return Val_int(155);
case CLANG_EXT_ATTR_MSNoVTable: return Val_int(156);
case CLANG_EXT_ATTR_MSP430Interrupt: return Val_int(157);
case CLANG_EXT_ATTR_MSStruct: return Val_int(158);
case CLANG_EXT_ATTR_MSVtorDisp: return Val_int(159);
case CLANG_EXT_ATTR_MaxFieldAlignment: return Val_int(160);
case CLANG_EXT_ATTR_MayAlias: return Val_int(161);
case CLANG_EXT_ATTR_MicroMips: return Val_int(162);
case CLANG_EXT_ATTR_MinSize: return Val_int(163);
case CLANG_EXT_ATTR_MinVectorWidth: return Val_int(164);
case CLANG_EXT_ATTR_Mips16: return Val_int(165);
case CLANG_EXT_ATTR_MipsInterrupt: return Val_int(166);
case CLANG_EXT_ATTR_MipsLongCall: return Val_int(167);
case CLANG_EXT_ATTR_MipsShortCall: return Val_int(168);
case CLANG_EXT_ATTR_NSConsumesSelf: return Val_int(169);
case CLANG_EXT_ATTR_NSReturnsAutoreleased: return Val_int(170);
case CLANG_EXT_ATTR_NSReturnsNotRetained: return Val_int(171);
case CLANG_EXT_ATTR_Naked: return Val_int(172);
case CLANG_EXT_ATTR_NoAlias: return Val_int(173);
case CLANG_EXT_ATTR_NoCommon: return Val_int(174);
case CLANG_EXT_ATTR_NoDebug: return Val_int(175);
case CLANG_EXT_ATTR_NoDestroy: return Val_int(176);
case CLANG_EXT_ATTR_NoDuplicate: return Val_int(177);
case CLANG_EXT_ATTR_NoInline: return Val_int(178);
case CLANG_EXT_ATTR_NoInstrumentFunction: return Val_int(179);
case CLANG_EXT_ATTR_NoMicroMips: return Val_int(180);
case CLANG_EXT_ATTR_NoMips16: return Val_int(181);
case CLANG_EXT_ATTR_NoReturn: return Val_int(182);
case CLANG_EXT_ATTR_NoSanitize: return Val_int(183);
case CLANG_EXT_ATTR_NoSpeculativeLoadHardening: return Val_int(184);
case CLANG_EXT_ATTR_NoSplitStack: return Val_int(185);
case CLANG_EXT_ATTR_NoStackProtector: return Val_int(186);
case CLANG_EXT_ATTR_NoThreadSafetyAnalysis: return Val_int(187);
case CLANG_EXT_ATTR_NoThrow: return Val_int(188);
case CLANG_EXT_ATTR_NoUniqueAddress: return Val_int(189);
case CLANG_EXT_ATTR_NotTailCalled: return Val_int(190);
case CLANG_EXT_ATTR_OMPAllocateDecl: return Val_int(191);
case CLANG_EXT_ATTR_OMPCaptureNoInit: return Val_int(192);
case CLANG_EXT_ATTR_OMPDeclareTargetDecl: return Val_int(193);
case CLANG_EXT_ATTR_OMPDeclareVariant: return Val_int(194);
case CLANG_EXT_ATTR_OMPThreadPrivateDecl: return Val_int(195);
case CLANG_EXT_ATTR_OSConsumesThis: return Val_int(196);
case CLANG_EXT_ATTR_OSReturnsNotRetained: return Val_int(197);
case CLANG_EXT_ATTR_OSReturnsRetained: return Val_int(198);
case CLANG_EXT_ATTR_OSReturnsRetainedOnNonZero: return Val_int(199);
case CLANG_EXT_ATTR_OSReturnsRetainedOnZero: return Val_int(200);
case CLANG_EXT_ATTR_ObjCBridge: return Val_int(201);
case CLANG_EXT_ATTR_ObjCBridgeMutable: return Val_int(202);
case CLANG_EXT_ATTR_ObjCBridgeRelated: return Val_int(203);
case CLANG_EXT_ATTR_ObjCException: return Val_int(204);
case CLANG_EXT_ATTR_ObjCExplicitProtocolImpl: return Val_int(205);
case CLANG_EXT_ATTR_ObjCExternallyRetained: return Val_int(206);
case CLANG_EXT_ATTR_ObjCIndependentClass: return Val_int(207);
case CLANG_EXT_ATTR_ObjCMethodFamily: return Val_int(208);
case CLANG_EXT_ATTR_ObjCNSObject: return Val_int(209);
case CLANG_EXT_ATTR_ObjCPreciseLifetime: return Val_int(210);
case CLANG_EXT_ATTR_ObjCRequiresPropertyDefs: return Val_int(211);
case CLANG_EXT_ATTR_ObjCRequiresSuper: return Val_int(212);
case CLANG_EXT_ATTR_ObjCReturnsInnerPointer: return Val_int(213);
case CLANG_EXT_ATTR_ObjCRootClass: return Val_int(214);
case CLANG_EXT_ATTR_ObjCSubclassingRestricted: return Val_int(215);
case CLANG_EXT_ATTR_OpenCLIntelReqdSubGroupSize: return Val_int(216);
case CLANG_EXT_ATTR_OpenCLKernel: return Val_int(217);
case CLANG_EXT_ATTR_OpenCLUnrollHint: return Val_int(218);
case CLANG_EXT_ATTR_OptimizeNone: return Val_int(219);
case CLANG_EXT_ATTR_Override: return Val_int(220);
case CLANG_EXT_ATTR_Owner: return Val_int(221);
case CLANG_EXT_ATTR_Ownership: return Val_int(222);
case CLANG_EXT_ATTR_Packed: return Val_int(223);
case CLANG_EXT_ATTR_ParamTypestate: return Val_int(224);
case CLANG_EXT_ATTR_PatchableFunctionEntry: return Val_int(225);
case CLANG_EXT_ATTR_Pointer: return Val_int(226);
case CLANG_EXT_ATTR_PragmaClangBSSSection: return Val_int(227);
case CLANG_EXT_ATTR_PragmaClangDataSection: return Val_int(228);
case CLANG_EXT_ATTR_PragmaClangRelroSection: return Val_int(229);
case CLANG_EXT_ATTR_PragmaClangRodataSection: return Val_int(230);
case CLANG_EXT_ATTR_PragmaClangTextSection: return Val_int(231);
case CLANG_EXT_ATTR_PtGuardedBy: return Val_int(232);
case CLANG_EXT_ATTR_PtGuardedVar: return Val_int(233);
case CLANG_EXT_ATTR_Pure: return Val_int(234);
case CLANG_EXT_ATTR_RISCVInterrupt: return Val_int(235);
case CLANG_EXT_ATTR_Reinitializes: return Val_int(236);
case CLANG_EXT_ATTR_ReleaseCapability: return Val_int(237);
case CLANG_EXT_ATTR_ReqdWorkGroupSize: return Val_int(238);
case CLANG_EXT_ATTR_RequiresCapability: return Val_int(239);
case CLANG_EXT_ATTR_Restrict: return Val_int(240);
case CLANG_EXT_ATTR_ReturnTypestate: return Val_int(241);
case CLANG_EXT_ATTR_ReturnsNonNull: return Val_int(242);
case CLANG_EXT_ATTR_ReturnsTwice: return Val_int(243);
case CLANG_EXT_ATTR_SYCLKernel: return Val_int(244);
case CLANG_EXT_ATTR_ScopedLockable: return Val_int(245);
case CLANG_EXT_ATTR_Section: return Val_int(246);
case CLANG_EXT_ATTR_SelectAny: return Val_int(247);
case CLANG_EXT_ATTR_Sentinel: return Val_int(248);
case CLANG_EXT_ATTR_SetTypestate: return Val_int(249);
case CLANG_EXT_ATTR_SharedTrylockFunction: return Val_int(250);
case CLANG_EXT_ATTR_SpeculativeLoadHardening: return Val_int(251);
case CLANG_EXT_ATTR_TLSModel: return Val_int(252);
case CLANG_EXT_ATTR_Target: return Val_int(253);
case CLANG_EXT_ATTR_TestTypestate: return Val_int(254);
case CLANG_EXT_ATTR_TransparentUnion: return Val_int(255);
case CLANG_EXT_ATTR_TrivialABI: return Val_int(256);
case CLANG_EXT_ATTR_TryAcquireCapability: return Val_int(257);
case CLANG_EXT_ATTR_TypeTagForDatatype: return Val_int(258);
case CLANG_EXT_ATTR_TypeVisibility: return Val_int(259);
case CLANG_EXT_ATTR_Unavailable: return Val_int(260);
case CLANG_EXT_ATTR_Uninitialized: return Val_int(261);
case CLANG_EXT_ATTR_Unused: return Val_int(262);
case CLANG_EXT_ATTR_Used: return Val_int(263);
case CLANG_EXT_ATTR_Uuid: return Val_int(264);
case CLANG_EXT_ATTR_VecReturn: return Val_int(265);
case CLANG_EXT_ATTR_VecTypeHint: return Val_int(266);
case CLANG_EXT_ATTR_Visibility: return Val_int(267);
case CLANG_EXT_ATTR_WarnUnused: return Val_int(268);
case CLANG_EXT_ATTR_WarnUnusedResult: return Val_int(269);
case CLANG_EXT_ATTR_Weak: return Val_int(270);
case CLANG_EXT_ATTR_WeakImport: return Val_int(271);
case CLANG_EXT_ATTR_WeakRef: return Val_int(272);
case CLANG_EXT_ATTR_WebAssemblyExportName: return Val_int(273);
case CLANG_EXT_ATTR_WebAssemblyImportModule: return Val_int(274);
case CLANG_EXT_ATTR_WebAssemblyImportName: return Val_int(275);
case CLANG_EXT_ATTR_WorkGroupSizeHint: return Val_int(276);
case CLANG_EXT_ATTR_X86ForceAlignArgPointer: return Val_int(277);
case CLANG_EXT_ATTR_XRayInstrument: return Val_int(278);
case CLANG_EXT_ATTR_XRayLogArgs: return Val_int(279);
case CLANG_EXT_ATTR_AbiTag: return Val_int(280);
case CLANG_EXT_ATTR_Alias: return Val_int(281);
case CLANG_EXT_ATTR_AlignValue: return Val_int(282);
case CLANG_EXT_ATTR_IFunc: return Val_int(283);
case CLANG_EXT_ATTR_InitSeg: return Val_int(284);
case CLANG_EXT_ATTR_LoaderUninitialized: return Val_int(285);
case CLANG_EXT_ATTR_LoopHint: return Val_int(286);
case CLANG_EXT_ATTR_Mode: return Val_int(287);
case CLANG_EXT_ATTR_NoBuiltin: return Val_int(288);
case CLANG_EXT_ATTR_NoEscape: return Val_int(289);
case CLANG_EXT_ATTR_OMPCaptureKind: return Val_int(290);
case CLANG_EXT_ATTR_OMPDeclareSimdDecl: return Val_int(291);
case CLANG_EXT_ATTR_OMPReferencedVar: return Val_int(292);
case CLANG_EXT_ATTR_ObjCBoxable: return Val_int(293);
case CLANG_EXT_ATTR_ObjCClassStub: return Val_int(294);
case CLANG_EXT_ATTR_ObjCDesignatedInitializer: return Val_int(295);
case CLANG_EXT_ATTR_ObjCDirect: return Val_int(296);
case CLANG_EXT_ATTR_ObjCDirectMembers: return Val_int(297);
case CLANG_EXT_ATTR_ObjCNonLazyClass: return Val_int(298);
case CLANG_EXT_ATTR_ObjCRuntimeName: return Val_int(299);
case CLANG_EXT_ATTR_ObjCRuntimeVisible: return Val_int(300);
case CLANG_EXT_ATTR_OpenCLAccess: return Val_int(301);
case CLANG_EXT_ATTR_Overloadable: return Val_int(302);
case CLANG_EXT_ATTR_RenderScriptKernel: return Val_int(303);
case CLANG_EXT_ATTR_Thread: return Val_int(304);
}
caml_failwith_fmt("invalid value for Val_clang_ext_attrkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AttrKind_GetSpelling_wrapper(value AttrKind_ocaml)
{
CAMLparam1(AttrKind_ocaml);
enum clang_ext_AttrKind AttrKind;
AttrKind = Clang_ext_attrkind_val(AttrKind_ocaml);
CXString result = clang_ext_AttrKind_GetSpelling(AttrKind);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXMethod_isDefaulted_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_CXXMethod_isDefaulted(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXMethod_isConst_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_CXXMethod_isConst(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXConstructor_isExplicit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_CXXConstructor_isExplicit(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_isDeleted_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_FunctionDecl_isDeleted(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_getNumParams_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_FunctionDecl_getNumParams(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_getParamDecl_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_FunctionDecl_getParamDecl(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_isConstexpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_FunctionDecl_isConstexpr(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_hasWrittenPrototype_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_FunctionDecl_hasWrittenPrototype(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_doesThisDeclarationHaveABody_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_FunctionDecl_doesThisDeclarationHaveABody(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_getBody_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_FunctionDecl_getBody(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LinkageSpecDecl_getLanguageIDs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_LinkageSpecDecl_getLanguageIDs(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateTypeParmDecl_getDefaultArgument_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXType result = clang_ext_TemplateTypeParmDecl_getDefaultArgument(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NonTypeTemplateParmDecl_getDefaultArgument_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_NonTypeTemplateParmDecl_getDefaultArgument(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_TemplateName_NameKind
Clang_ext_templatename_namekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_Template;
case 1: return CLANG_EXT_OverloadedTemplate;
case 2: return CLANG_EXT_AssumedTemplate;
case 3: return CLANG_EXT_QualifiedTemplate;
case 4: return CLANG_EXT_DependentTemplate;
case 5: return CLANG_EXT_SubstTemplateTemplateParm;
case 6: return CLANG_EXT_SubstTemplateTemplateParmPack;
case 7: return CLANG_EXT_InvalidNameKind;
}
caml_failwith_fmt("invalid value for Clang_ext_templatename_namekind_val: %d", Int_val(ocaml));
return CLANG_EXT_Template;
}
value
Val_clang_ext_templatename_namekind(enum clang_ext_TemplateName_NameKind v)
{
switch (v) {
case CLANG_EXT_Template: return Val_int(0);
case CLANG_EXT_OverloadedTemplate: return Val_int(1);
case CLANG_EXT_AssumedTemplate: return Val_int(2);
case CLANG_EXT_QualifiedTemplate: return Val_int(3);
case CLANG_EXT_DependentTemplate: return Val_int(4);
case CLANG_EXT_SubstTemplateTemplateParm: return Val_int(5);
case CLANG_EXT_SubstTemplateTemplateParmPack: return Val_int(6);
case CLANG_EXT_InvalidNameKind: return Val_int(7);
}
caml_failwith_fmt("invalid value for Val_clang_ext_templatename_namekind: %d", v);
return Val_int(0);
}
static void finalize_clang_ext_templatename(value v) {
clang_ext_TemplateName_dispose(*((struct clang_ext_TemplateName *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_TemplateName, clang_ext_templatename, Clang_ext_templatename_val, Val_clang_ext_templatename, finalize_clang_ext_templatename, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_TemplateName_getKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateName arg;
arg = Clang_ext_templatename_val(Field(arg_ocaml, 0));
enum clang_ext_TemplateName_NameKind result = clang_ext_TemplateName_getKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_templatename_namekind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateName_getAsTemplateDecl_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateName arg;
arg = Clang_ext_templatename_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_TemplateName_getAsTemplateDecl(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
static void finalize_clang_ext_templateargument(value v) {
clang_ext_TemplateArgument_dispose(*((struct clang_ext_TemplateArgument *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_TemplateArgument, clang_ext_templateargument, Clang_ext_templateargument_val, Val_clang_ext_templateargument, finalize_clang_ext_templateargument, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_TemplateArgument_getKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
enum CXTemplateArgumentKind result = clang_ext_TemplateArgument_getKind(arg);
{
CAMLlocal1(data);
data = Val_cxtemplateargumentkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getAsType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
CXType result = clang_ext_TemplateArgument_getAsType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getAsDecl_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_TemplateArgument_getAsDecl(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getNullPtrType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
CXType result = clang_ext_TemplateArgument_getNullPtrType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getAsTemplateOrTemplatePattern_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
struct clang_ext_TemplateName result = clang_ext_TemplateArgument_getAsTemplateOrTemplatePattern(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templatename(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getAsIntegral_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
CXInt result = clang_ext_TemplateArgument_getAsIntegral(arg);
{
CAMLlocal1(data);
data = Val_cxint(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getIntegralType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
CXType result = clang_ext_TemplateArgument_getIntegralType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getAsExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_TemplateArgument_getAsExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getPackSize_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_TemplateArgument_getPackSize(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getPackArgument_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
struct clang_ext_TemplateArgument result = clang_ext_TemplateArgument_getPackArgument(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templateargument(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateArgument_getPackExpansionPattern_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateArgument arg;
arg = Clang_ext_templateargument_val(Field(arg_ocaml, 0));
struct clang_ext_TemplateArgument result = clang_ext_TemplateArgument_getPackExpansionPattern(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templateargument(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateSpecializationType_getTemplateName_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
struct clang_ext_TemplateName result = clang_ext_TemplateSpecializationType_getTemplateName(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templatename(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateSpecializationType_getNumArgs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_TemplateSpecializationType_getNumArgs(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateSpecializationType_getArgument_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
struct clang_ext_TemplateArgument result = clang_ext_TemplateSpecializationType_getArgument(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templateargument(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FriendDecl_getFriendDecl_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_FriendDecl_getFriendDecl(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FriendDecl_getFriendType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXType result = clang_ext_FriendDecl_getFriendType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FieldDecl_getInClassInitializer_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_FieldDecl_getInClassInitializer(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_GenericSelectionExpr_getAssocType_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXType result = clang_ext_GenericSelectionExpr_getAssocType(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateParm_isParameterPack_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_TemplateParm_isParameterPack(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateDecl_getTemplatedDecl_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_TemplateDecl_getTemplatedDecl(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_PredefinedExpr_IdentKind
Clang_ext_predefinedexpr_identkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PredefinedExpr_Func;
case 1: return clang_ext_PredefinedExpr_Function;
case 2: return clang_ext_PredefinedExpr_LFunction;
case 3: return clang_ext_PredefinedExpr_FuncDName;
case 4: return clang_ext_PredefinedExpr_FuncSig;
case 5: return clang_ext_PredefinedExpr_LFuncSig;
case 6: return clang_ext_PredefinedExpr_PrettyFunction;
case 7: return clang_ext_PredefinedExpr_PrettyFunctionNoVirtual;
case 8: return clang_ext_PredefinedExpr_InvalidPredefinedExpr;
}
caml_failwith_fmt("invalid value for Clang_ext_predefinedexpr_identkind_val: %d", Int_val(ocaml));
return clang_ext_PredefinedExpr_Func;
}
value
Val_clang_ext_predefinedexpr_identkind(enum clang_ext_PredefinedExpr_IdentKind v)
{
switch (v) {
case clang_ext_PredefinedExpr_Func: return Val_int(0);
case clang_ext_PredefinedExpr_Function: return Val_int(1);
case clang_ext_PredefinedExpr_LFunction: return Val_int(2);
case clang_ext_PredefinedExpr_FuncDName: return Val_int(3);
case clang_ext_PredefinedExpr_FuncSig: return Val_int(4);
case clang_ext_PredefinedExpr_LFuncSig: return Val_int(5);
case clang_ext_PredefinedExpr_PrettyFunction: return Val_int(6);
case clang_ext_PredefinedExpr_PrettyFunctionNoVirtual: return Val_int(7);
case clang_ext_PredefinedExpr_InvalidPredefinedExpr: return Val_int(8);
}
caml_failwith_fmt("invalid value for Val_clang_ext_predefinedexpr_identkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PredefinedExpr_getIdentKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_PredefinedExpr_IdentKind result = clang_ext_PredefinedExpr_getIdentKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_predefinedexpr_identkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PredefinedExpr_getFunctionName_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_ext_PredefinedExpr_getFunctionName(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PredefinedExpr_ComputeName_wrapper(value kind_ocaml, value decl_ocaml)
{
CAMLparam2(kind_ocaml, decl_ocaml);
enum clang_ext_PredefinedExpr_IdentKind kind;
kind = Clang_ext_predefinedexpr_identkind_val(kind_ocaml);
CXCursor decl;
decl = Cxcursor_val(Field(decl_ocaml, 0));
CXString result = clang_ext_PredefinedExpr_ComputeName(kind, decl);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LambdaExpr_isMutable_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_LambdaExpr_isMutable(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LambdaExpr_hasExplicitParameters_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_LambdaExpr_hasExplicitParameters(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LambdaExpr_hasExplicitResultType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_LambdaExpr_hasExplicitResultType(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum clang_ext_LambdaCaptureDefault
Clang_ext_lambdacapturedefault_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_LCD_CaptureNone;
case 1: return clang_ext_LCD_ByCopy;
case 2: return clang_ext_LCD_ByRef;
}
caml_failwith_fmt("invalid value for Clang_ext_lambdacapturedefault_val: %d", Int_val(ocaml));
return clang_ext_LCD_CaptureNone;
}
value
Val_clang_ext_lambdacapturedefault(enum clang_ext_LambdaCaptureDefault v)
{
switch (v) {
case clang_ext_LCD_CaptureNone: return Val_int(0);
case clang_ext_LCD_ByCopy: return Val_int(1);
case clang_ext_LCD_ByRef: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_lambdacapturedefault: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LambdaExpr_getCaptureDefault_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_LambdaCaptureDefault result = clang_ext_LambdaExpr_getCaptureDefault(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_lambdacapturedefault(result);
CAMLreturn(data);
}
}
static void finalize_clang_ext_lambdacapture(value v) {
clang_ext_LambdaCapture_dispose(*((struct clang_ext_LambdaCapture *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_LambdaCapture, clang_ext_lambdacapture, Clang_ext_lambdacapture_val, Val_clang_ext_lambdacapture, finalize_clang_ext_lambdacapture, custom_compare_default, custom_hash_default)
void
clang_ext_LambdaExpr_getCaptures_arg2_callback(struct clang_ext_LambdaCapture arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_clang_ext_lambdacapture(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_LambdaExpr_getCaptures_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
clang_ext_LambdaExpr_getCaptures(arg, clang_ext_LambdaExpr_getCaptures_arg2_callback, (value *[]){&arg2_ocaml,&arg_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_LambdaExpr_getCallOperator_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_LambdaExpr_getCallOperator(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_LambdaCaptureKind
Clang_ext_lambdacapturekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_LCK_This;
case 1: return clang_ext_LCK_StarThis;
case 2: return clang_ext_LCK_ByCopy;
case 3: return clang_ext_LCK_ByRef;
case 4: return clang_ext_LCK_VLAType;
}
caml_failwith_fmt("invalid value for Clang_ext_lambdacapturekind_val: %d", Int_val(ocaml));
return clang_ext_LCK_This;
}
value
Val_clang_ext_lambdacapturekind(enum clang_ext_LambdaCaptureKind v)
{
switch (v) {
case clang_ext_LCK_This: return Val_int(0);
case clang_ext_LCK_StarThis: return Val_int(1);
case clang_ext_LCK_ByCopy: return Val_int(2);
case clang_ext_LCK_ByRef: return Val_int(3);
case clang_ext_LCK_VLAType: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_lambdacapturekind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LambdaCapture_getKind_wrapper(value capture_ocaml)
{
CAMLparam1(capture_ocaml);
struct clang_ext_LambdaCapture capture;
capture = Clang_ext_lambdacapture_val(Field(capture_ocaml, 0));
enum clang_ext_LambdaCaptureKind result = clang_ext_LambdaCapture_getKind(capture);
{
CAMLlocal1(data);
data = Val_clang_ext_lambdacapturekind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LambdaCapture_getCapturedVar_wrapper(value capture_ocaml)
{
CAMLparam1(capture_ocaml);
struct clang_ext_LambdaCapture capture;
capture = Clang_ext_lambdacapture_val(Field(capture_ocaml, 0));
CXCursor result = clang_ext_LambdaCapture_getCapturedVar(capture);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(capture_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LambdaCapture_isImplicit_wrapper(value capture_ocaml)
{
CAMLparam1(capture_ocaml);
struct clang_ext_LambdaCapture capture;
capture = Clang_ext_lambdacapture_val(Field(capture_ocaml, 0));
_Bool result = clang_ext_LambdaCapture_isImplicit(capture);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LambdaCapture_isPackExpansion_wrapper(value capture_ocaml)
{
CAMLparam1(capture_ocaml);
struct clang_ext_LambdaCapture capture;
capture = Clang_ext_lambdacapture_val(Field(capture_ocaml, 0));
_Bool result = clang_ext_LambdaCapture_isPackExpansion(capture);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXNewExpr_getAllocatedTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_CXXNewExpr_getAllocatedTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXNewExpr_getArraySize_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXNewExpr_getArraySize(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXNewExpr_getNumPlacementArgs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_CXXNewExpr_getNumPlacementArgs(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXNewExpr_getPlacementArg_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_CXXNewExpr_getPlacementArg(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXNewExpr_getInitializer_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXNewExpr_getInitializer(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXDeleteExpr_isGlobalDelete_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXDeleteExpr_isGlobalDelete(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXDeleteExpr_isArrayForm_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXDeleteExpr_isArrayForm(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXTypeidExpr_isTypeOperand_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXTypeidExpr_isTypeOperand(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXTypeidExpr_getTypeOperand_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_CXXTypeidExpr_getTypeOperand(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXTypeidExpr_getExprOperand_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXTypeidExpr_getExprOperand(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_langstandards
Clang_ext_langstandards_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_LANGSTANDARDS_c89;
case 1: return CLANG_EXT_LANGSTANDARDS_c94;
case 2: return CLANG_EXT_LANGSTANDARDS_gnu89;
case 3: return CLANG_EXT_LANGSTANDARDS_c99;
case 4: return CLANG_EXT_LANGSTANDARDS_gnu99;
case 5: return CLANG_EXT_LANGSTANDARDS_c11;
case 6: return CLANG_EXT_LANGSTANDARDS_gnu11;
case 7: return CLANG_EXT_LANGSTANDARDS_c17;
case 8: return CLANG_EXT_LANGSTANDARDS_gnu17;
case 9: return CLANG_EXT_LANGSTANDARDS_c2x;
case 10: return CLANG_EXT_LANGSTANDARDS_gnu2x;
case 11: return CLANG_EXT_LANGSTANDARDS_cxx98;
case 12: return CLANG_EXT_LANGSTANDARDS_gnucxx98;
case 13: return CLANG_EXT_LANGSTANDARDS_cxx11;
case 14: return CLANG_EXT_LANGSTANDARDS_gnucxx11;
case 15: return CLANG_EXT_LANGSTANDARDS_cxx14;
case 16: return CLANG_EXT_LANGSTANDARDS_gnucxx14;
case 17: return CLANG_EXT_LANGSTANDARDS_cxx17;
case 18: return CLANG_EXT_LANGSTANDARDS_gnucxx17;
case 19: return CLANG_EXT_LANGSTANDARDS_cxx20;
case 20: return CLANG_EXT_LANGSTANDARDS_gnucxx20;
case 21: return CLANG_EXT_LANGSTANDARDS_opencl10;
case 22: return CLANG_EXT_LANGSTANDARDS_opencl11;
case 23: return CLANG_EXT_LANGSTANDARDS_opencl12;
case 24: return CLANG_EXT_LANGSTANDARDS_opencl20;
case 25: return CLANG_EXT_LANGSTANDARDS_openclcpp;
case 26: return CLANG_EXT_LANGSTANDARDS_cuda;
case 27: return CLANG_EXT_LANGSTANDARDS_hip;
case 28: return CLANG_EXT_LANGSTANDARDS_InvalidLang;
}
caml_failwith_fmt("invalid value for Clang_ext_langstandards_val: %d", Int_val(ocaml));
return CLANG_EXT_LANGSTANDARDS_c89;
}
value
Val_clang_ext_langstandards(enum clang_ext_langstandards v)
{
switch (v) {
case CLANG_EXT_LANGSTANDARDS_c89: return Val_int(0);
case CLANG_EXT_LANGSTANDARDS_c94: return Val_int(1);
case CLANG_EXT_LANGSTANDARDS_gnu89: return Val_int(2);
case CLANG_EXT_LANGSTANDARDS_c99: return Val_int(3);
case CLANG_EXT_LANGSTANDARDS_gnu99: return Val_int(4);
case CLANG_EXT_LANGSTANDARDS_c11: return Val_int(5);
case CLANG_EXT_LANGSTANDARDS_gnu11: return Val_int(6);
case CLANG_EXT_LANGSTANDARDS_c17: return Val_int(7);
case CLANG_EXT_LANGSTANDARDS_gnu17: return Val_int(8);
case CLANG_EXT_LANGSTANDARDS_c2x: return Val_int(9);
case CLANG_EXT_LANGSTANDARDS_gnu2x: return Val_int(10);
case CLANG_EXT_LANGSTANDARDS_cxx98: return Val_int(11);
case CLANG_EXT_LANGSTANDARDS_gnucxx98: return Val_int(12);
case CLANG_EXT_LANGSTANDARDS_cxx11: return Val_int(13);
case CLANG_EXT_LANGSTANDARDS_gnucxx11: return Val_int(14);
case CLANG_EXT_LANGSTANDARDS_cxx14: return Val_int(15);
case CLANG_EXT_LANGSTANDARDS_gnucxx14: return Val_int(16);
case CLANG_EXT_LANGSTANDARDS_cxx17: return Val_int(17);
case CLANG_EXT_LANGSTANDARDS_gnucxx17: return Val_int(18);
case CLANG_EXT_LANGSTANDARDS_cxx20: return Val_int(19);
case CLANG_EXT_LANGSTANDARDS_gnucxx20: return Val_int(20);
case CLANG_EXT_LANGSTANDARDS_opencl10: return Val_int(21);
case CLANG_EXT_LANGSTANDARDS_opencl11: return Val_int(22);
case CLANG_EXT_LANGSTANDARDS_opencl12: return Val_int(23);
case CLANG_EXT_LANGSTANDARDS_opencl20: return Val_int(24);
case CLANG_EXT_LANGSTANDARDS_openclcpp: return Val_int(25);
case CLANG_EXT_LANGSTANDARDS_cuda: return Val_int(26);
case CLANG_EXT_LANGSTANDARDS_hip: return Val_int(27);
case CLANG_EXT_LANGSTANDARDS_InvalidLang: return Val_int(28);
}
caml_failwith_fmt("invalid value for Val_clang_ext_langstandards: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LangStandard_getName_wrapper(value s_ocaml)
{
CAMLparam1(s_ocaml);
enum clang_ext_langstandards s;
s = Clang_ext_langstandards_val(s_ocaml);
const char * result = clang_ext_LangStandard_getName(s);
{
CAMLlocal1(data);
data = caml_copy_string(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LangStandard_ofName_wrapper(value s_ocaml)
{
CAMLparam1(s_ocaml);
const char * s;
s = String_val(s_ocaml);
enum clang_ext_langstandards result = clang_ext_LangStandard_ofName(s);
{
CAMLlocal1(data);
data = Val_clang_ext_langstandards(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PackExpansion_getPattern_wrapper(value c_ocaml)
{
CAMLparam1(c_ocaml);
CXType c;
c = Cxtype_val(Field(c_ocaml, 0));
CXType result = clang_ext_PackExpansion_getPattern(c);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(c_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXFoldExpr_isRightFold_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXFoldExpr_isRightFold(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXFoldExpr_getOperator_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_BinaryOperatorKind result = clang_ext_CXXFoldExpr_getOperator(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_binaryoperatorkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXBoolLiteralExpr_getValue_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXBoolLiteralExpr_getValue(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CallExpr_getCallee_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CallExpr_getCallee(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CallExpr_getNumArgs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_CallExpr_getNumArgs(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CallExpr_getArg_wrapper(value arg_ocaml, value i_ocaml)
{
CAMLparam2(arg_ocaml, i_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int i;
i = Int_val(i_ocaml);
CXCursor result = clang_ext_CallExpr_getArg(arg, i);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SizeOfPackExpr_getPack_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_SizeOfPackExpr_getPack(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DecltypeType_getUnderlyingExpr_wrapper(value t_ocaml)
{
CAMLparam1(t_ocaml);
CXType t;
t = Cxtype_val(Field(t_ocaml, 0));
CXCursor result = clang_ext_DecltypeType_getUnderlyingExpr(t);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(t_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NamespaceDecl_isInline_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_NamespaceDecl_isInline(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum clang_ext_OverloadedOperatorKind
Clang_ext_overloadedoperatorkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_OVERLOADED_OPERATOR_InvalidOverloadedOperator;
case 1: return CLANG_EXT_OVERLOADED_OPERATOR_New;
case 2: return CLANG_EXT_OVERLOADED_OPERATOR_Delete;
case 3: return CLANG_EXT_OVERLOADED_OPERATOR_Array_New;
case 4: return CLANG_EXT_OVERLOADED_OPERATOR_Array_Delete;
case 5: return CLANG_EXT_OVERLOADED_OPERATOR_Plus;
case 6: return CLANG_EXT_OVERLOADED_OPERATOR_Minus;
case 7: return CLANG_EXT_OVERLOADED_OPERATOR_Star;
case 8: return CLANG_EXT_OVERLOADED_OPERATOR_Slash;
case 9: return CLANG_EXT_OVERLOADED_OPERATOR_Percent;
case 10: return CLANG_EXT_OVERLOADED_OPERATOR_Caret;
case 11: return CLANG_EXT_OVERLOADED_OPERATOR_Amp;
case 12: return CLANG_EXT_OVERLOADED_OPERATOR_Pipe;
case 13: return CLANG_EXT_OVERLOADED_OPERATOR_Tilde;
case 14: return CLANG_EXT_OVERLOADED_OPERATOR_Exclaim;
case 15: return CLANG_EXT_OVERLOADED_OPERATOR_Equal;
case 16: return CLANG_EXT_OVERLOADED_OPERATOR_Less;
case 17: return CLANG_EXT_OVERLOADED_OPERATOR_Greater;
case 18: return CLANG_EXT_OVERLOADED_OPERATOR_PlusEqual;
case 19: return CLANG_EXT_OVERLOADED_OPERATOR_MinusEqual;
case 20: return CLANG_EXT_OVERLOADED_OPERATOR_StarEqual;
case 21: return CLANG_EXT_OVERLOADED_OPERATOR_SlashEqual;
case 22: return CLANG_EXT_OVERLOADED_OPERATOR_PercentEqual;
case 23: return CLANG_EXT_OVERLOADED_OPERATOR_CaretEqual;
case 24: return CLANG_EXT_OVERLOADED_OPERATOR_AmpEqual;
case 25: return CLANG_EXT_OVERLOADED_OPERATOR_PipeEqual;
case 26: return CLANG_EXT_OVERLOADED_OPERATOR_LessLess;
case 27: return CLANG_EXT_OVERLOADED_OPERATOR_GreaterGreater;
case 28: return CLANG_EXT_OVERLOADED_OPERATOR_LessLessEqual;
case 29: return CLANG_EXT_OVERLOADED_OPERATOR_GreaterGreaterEqual;
case 30: return CLANG_EXT_OVERLOADED_OPERATOR_EqualEqual;
case 31: return CLANG_EXT_OVERLOADED_OPERATOR_ExclaimEqual;
case 32: return CLANG_EXT_OVERLOADED_OPERATOR_LessEqual;
case 33: return CLANG_EXT_OVERLOADED_OPERATOR_GreaterEqual;
case 34: return CLANG_EXT_OVERLOADED_OPERATOR_Spaceship;
case 35: return CLANG_EXT_OVERLOADED_OPERATOR_AmpAmp;
case 36: return CLANG_EXT_OVERLOADED_OPERATOR_PipePipe;
case 37: return CLANG_EXT_OVERLOADED_OPERATOR_PlusPlus;
case 38: return CLANG_EXT_OVERLOADED_OPERATOR_MinusMinus;
case 39: return CLANG_EXT_OVERLOADED_OPERATOR_Comma;
case 40: return CLANG_EXT_OVERLOADED_OPERATOR_ArrowStar;
case 41: return CLANG_EXT_OVERLOADED_OPERATOR_Arrow;
case 42: return CLANG_EXT_OVERLOADED_OPERATOR_Call;
case 43: return CLANG_EXT_OVERLOADED_OPERATOR_Subscript;
case 44: return CLANG_EXT_OVERLOADED_OPERATOR_Conditional;
case 45: return CLANG_EXT_OVERLOADED_OPERATOR_Coawait;
}
caml_failwith_fmt("invalid value for Clang_ext_overloadedoperatorkind_val: %d", Int_val(ocaml));
return CLANG_EXT_OVERLOADED_OPERATOR_InvalidOverloadedOperator;
}
value
Val_clang_ext_overloadedoperatorkind(enum clang_ext_OverloadedOperatorKind v)
{
switch (v) {
case CLANG_EXT_OVERLOADED_OPERATOR_InvalidOverloadedOperator: return Val_int(0);
case CLANG_EXT_OVERLOADED_OPERATOR_New: return Val_int(1);
case CLANG_EXT_OVERLOADED_OPERATOR_Delete: return Val_int(2);
case CLANG_EXT_OVERLOADED_OPERATOR_Array_New: return Val_int(3);
case CLANG_EXT_OVERLOADED_OPERATOR_Array_Delete: return Val_int(4);
case CLANG_EXT_OVERLOADED_OPERATOR_Plus: return Val_int(5);
case CLANG_EXT_OVERLOADED_OPERATOR_Minus: return Val_int(6);
case CLANG_EXT_OVERLOADED_OPERATOR_Star: return Val_int(7);
case CLANG_EXT_OVERLOADED_OPERATOR_Slash: return Val_int(8);
case CLANG_EXT_OVERLOADED_OPERATOR_Percent: return Val_int(9);
case CLANG_EXT_OVERLOADED_OPERATOR_Caret: return Val_int(10);
case CLANG_EXT_OVERLOADED_OPERATOR_Amp: return Val_int(11);
case CLANG_EXT_OVERLOADED_OPERATOR_Pipe: return Val_int(12);
case CLANG_EXT_OVERLOADED_OPERATOR_Tilde: return Val_int(13);
case CLANG_EXT_OVERLOADED_OPERATOR_Exclaim: return Val_int(14);
case CLANG_EXT_OVERLOADED_OPERATOR_Equal: return Val_int(15);
case CLANG_EXT_OVERLOADED_OPERATOR_Less: return Val_int(16);
case CLANG_EXT_OVERLOADED_OPERATOR_Greater: return Val_int(17);
case CLANG_EXT_OVERLOADED_OPERATOR_PlusEqual: return Val_int(18);
case CLANG_EXT_OVERLOADED_OPERATOR_MinusEqual: return Val_int(19);
case CLANG_EXT_OVERLOADED_OPERATOR_StarEqual: return Val_int(20);
case CLANG_EXT_OVERLOADED_OPERATOR_SlashEqual: return Val_int(21);
case CLANG_EXT_OVERLOADED_OPERATOR_PercentEqual: return Val_int(22);
case CLANG_EXT_OVERLOADED_OPERATOR_CaretEqual: return Val_int(23);
case CLANG_EXT_OVERLOADED_OPERATOR_AmpEqual: return Val_int(24);
case CLANG_EXT_OVERLOADED_OPERATOR_PipeEqual: return Val_int(25);
case CLANG_EXT_OVERLOADED_OPERATOR_LessLess: return Val_int(26);
case CLANG_EXT_OVERLOADED_OPERATOR_GreaterGreater: return Val_int(27);
case CLANG_EXT_OVERLOADED_OPERATOR_LessLessEqual: return Val_int(28);
case CLANG_EXT_OVERLOADED_OPERATOR_GreaterGreaterEqual: return Val_int(29);
case CLANG_EXT_OVERLOADED_OPERATOR_EqualEqual: return Val_int(30);
case CLANG_EXT_OVERLOADED_OPERATOR_ExclaimEqual: return Val_int(31);
case CLANG_EXT_OVERLOADED_OPERATOR_LessEqual: return Val_int(32);
case CLANG_EXT_OVERLOADED_OPERATOR_GreaterEqual: return Val_int(33);
case CLANG_EXT_OVERLOADED_OPERATOR_Spaceship: return Val_int(34);
case CLANG_EXT_OVERLOADED_OPERATOR_AmpAmp: return Val_int(35);
case CLANG_EXT_OVERLOADED_OPERATOR_PipePipe: return Val_int(36);
case CLANG_EXT_OVERLOADED_OPERATOR_PlusPlus: return Val_int(37);
case CLANG_EXT_OVERLOADED_OPERATOR_MinusMinus: return Val_int(38);
case CLANG_EXT_OVERLOADED_OPERATOR_Comma: return Val_int(39);
case CLANG_EXT_OVERLOADED_OPERATOR_ArrowStar: return Val_int(40);
case CLANG_EXT_OVERLOADED_OPERATOR_Arrow: return Val_int(41);
case CLANG_EXT_OVERLOADED_OPERATOR_Call: return Val_int(42);
case CLANG_EXT_OVERLOADED_OPERATOR_Subscript: return Val_int(43);
case CLANG_EXT_OVERLOADED_OPERATOR_Conditional: return Val_int(44);
case CLANG_EXT_OVERLOADED_OPERATOR_Coawait: return Val_int(45);
}
caml_failwith_fmt("invalid value for Val_clang_ext_overloadedoperatorkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OverloadedOperator_getSpelling_wrapper(value kind_ocaml)
{
CAMLparam1(kind_ocaml);
enum clang_ext_OverloadedOperatorKind kind;
kind = Clang_ext_overloadedoperatorkind_val(kind_ocaml);
const char * result = clang_ext_OverloadedOperator_getSpelling(kind);
{
CAMLlocal1(data);
data = caml_copy_string(result);
CAMLreturn(data);
}
}
enum clang_ext_DeclarationNameKind
Clang_ext_declarationnamekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_DECLARATION_NAME_Identifier;
case 1: return CLANG_EXT_DECLARATION_NAME_ObjCZeroArgSelector;
case 2: return CLANG_EXT_DECLARATION_NAME_ObjCOneArgSelector;
case 3: return CLANG_EXT_DECLARATION_NAME_ObjCMultiArgSelector;
case 4: return CLANG_EXT_DECLARATION_NAME_CXXConstructorName;
case 5: return CLANG_EXT_DECLARATION_NAME_CXXDestructorName;
case 6: return CLANG_EXT_DECLARATION_NAME_CXXConversionFunctionName;
case 7: return CLANG_EXT_DECLARATION_NAME_CXXDeductionGuideName;
case 8: return CLANG_EXT_DECLARATION_NAME_CXXOperatorName;
case 9: return CLANG_EXT_DECLARATION_NAME_CXXLiteralOperatorName;
case 10: return CLANG_EXT_DECLARATION_NAME_CXXUsingDirective;
case 11: return CLANG_EXT_DECLARATION_NAME_InvalidDeclarationName;
}
caml_failwith_fmt("invalid value for Clang_ext_declarationnamekind_val: %d", Int_val(ocaml));
return CLANG_EXT_DECLARATION_NAME_Identifier;
}
value
Val_clang_ext_declarationnamekind(enum clang_ext_DeclarationNameKind v)
{
switch (v) {
case CLANG_EXT_DECLARATION_NAME_Identifier: return Val_int(0);
case CLANG_EXT_DECLARATION_NAME_ObjCZeroArgSelector: return Val_int(1);
case CLANG_EXT_DECLARATION_NAME_ObjCOneArgSelector: return Val_int(2);
case CLANG_EXT_DECLARATION_NAME_ObjCMultiArgSelector: return Val_int(3);
case CLANG_EXT_DECLARATION_NAME_CXXConstructorName: return Val_int(4);
case CLANG_EXT_DECLARATION_NAME_CXXDestructorName: return Val_int(5);
case CLANG_EXT_DECLARATION_NAME_CXXConversionFunctionName: return Val_int(6);
case CLANG_EXT_DECLARATION_NAME_CXXDeductionGuideName: return Val_int(7);
case CLANG_EXT_DECLARATION_NAME_CXXOperatorName: return Val_int(8);
case CLANG_EXT_DECLARATION_NAME_CXXLiteralOperatorName: return Val_int(9);
case CLANG_EXT_DECLARATION_NAME_CXXUsingDirective: return Val_int(10);
case CLANG_EXT_DECLARATION_NAME_InvalidDeclarationName: return Val_int(11);
}
caml_failwith_fmt("invalid value for Val_clang_ext_declarationnamekind: %d", v);
return Val_int(0);
}
static void finalize_clang_ext_declarationname(value v) {
clang_ext_DeclarationName_dispose(*((struct clang_ext_DeclarationName *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_DeclarationName, clang_ext_declarationname, Clang_ext_declarationname_val, Val_clang_ext_declarationname, finalize_clang_ext_declarationname, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_DeclarationName_getKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_DeclarationName arg;
arg = Clang_ext_declarationname_val(Field(arg_ocaml, 0));
enum clang_ext_DeclarationNameKind result = clang_ext_DeclarationName_getKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_declarationnamekind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DeclarationName_getCXXOverloadedOperator_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_DeclarationName arg;
arg = Clang_ext_declarationname_val(Field(arg_ocaml, 0));
enum clang_ext_OverloadedOperatorKind result = clang_ext_DeclarationName_getCXXOverloadedOperator(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_overloadedoperatorkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DeclarationName_getCXXNameType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_DeclarationName arg;
arg = Clang_ext_declarationname_val(Field(arg_ocaml, 0));
CXType result = clang_ext_DeclarationName_getCXXNameType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DeclarationName_getAsIdentifier_wrapper(value name_ocaml)
{
CAMLparam1(name_ocaml);
struct clang_ext_DeclarationName name;
name = Clang_ext_declarationname_val(Field(name_ocaml, 0));
CXString result = clang_ext_DeclarationName_getAsIdentifier(name);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DeclarationName_getCXXDeductionGuideTemplate_wrapper(value name_ocaml)
{
CAMLparam1(name_ocaml);
struct clang_ext_DeclarationName name;
name = Clang_ext_declarationname_val(Field(name_ocaml, 0));
CXCursor result = clang_ext_DeclarationName_getCXXDeductionGuideTemplate(name);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(name_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DeclarationName_getCXXLiteralIdentifier_wrapper(value name_ocaml)
{
CAMLparam1(name_ocaml);
struct clang_ext_DeclarationName name;
name = Clang_ext_declarationname_val(Field(name_ocaml, 0));
CXString result = clang_ext_DeclarationName_getCXXLiteralIdentifier(name);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Decl_getName_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_DeclarationName result = clang_ext_Decl_getName(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_declarationname(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_UsingDirectiveDecl_getNominatedNamespace_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_UsingDirectiveDecl_getNominatedNamespace(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_NestedNameSpecifierKind
Clang_ext_nestednamespecifierkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_NESTED_NAME_SPECIFIER_InvalidNestedNameSpecifier;
case 1: return CLANG_EXT_NESTED_NAME_SPECIFIER_Identifier;
case 2: return CLANG_EXT_NESTED_NAME_SPECIFIER_Namespace;
case 3: return CLANG_EXT_NESTED_NAME_SPECIFIER_NamespaceAlias;
case 4: return CLANG_EXT_NESTED_NAME_SPECIFIER_TypeSpec;
case 5: return CLANG_EXT_NESTED_NAME_SPECIFIER_TypeSpecWithTemplate;
case 6: return CLANG_EXT_NESTED_NAME_SPECIFIER_Global;
case 7: return CLANG_EXT_NESTED_NAME_SPECIFIER_Super;
}
caml_failwith_fmt("invalid value for Clang_ext_nestednamespecifierkind_val: %d", Int_val(ocaml));
return CLANG_EXT_NESTED_NAME_SPECIFIER_InvalidNestedNameSpecifier;
}
value
Val_clang_ext_nestednamespecifierkind(enum clang_ext_NestedNameSpecifierKind v)
{
switch (v) {
case CLANG_EXT_NESTED_NAME_SPECIFIER_InvalidNestedNameSpecifier: return Val_int(0);
case CLANG_EXT_NESTED_NAME_SPECIFIER_Identifier: return Val_int(1);
case CLANG_EXT_NESTED_NAME_SPECIFIER_Namespace: return Val_int(2);
case CLANG_EXT_NESTED_NAME_SPECIFIER_NamespaceAlias: return Val_int(3);
case CLANG_EXT_NESTED_NAME_SPECIFIER_TypeSpec: return Val_int(4);
case CLANG_EXT_NESTED_NAME_SPECIFIER_TypeSpecWithTemplate: return Val_int(5);
case CLANG_EXT_NESTED_NAME_SPECIFIER_Global: return Val_int(6);
case CLANG_EXT_NESTED_NAME_SPECIFIER_Super: return Val_int(7);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nestednamespecifierkind: %d", v);
return Val_int(0);
}
DECLARE_OPAQUE_EX(struct clang_ext_NestedNameSpecifier, clang_ext_nestednamespecifier, Clang_ext_nestednamespecifier_val, Val_clang_ext_nestednamespecifier, custom_finalize_default, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_NestedNameSpecifier_getKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifier arg;
arg = Clang_ext_nestednamespecifier_val(Field(arg_ocaml, 0));
enum clang_ext_NestedNameSpecifierKind result = clang_ext_NestedNameSpecifier_getKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_nestednamespecifierkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NestedNameSpecifier_getPrefix_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifier arg;
arg = Clang_ext_nestednamespecifier_val(Field(arg_ocaml, 0));
struct clang_ext_NestedNameSpecifier result = clang_ext_NestedNameSpecifier_getPrefix(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_nestednamespecifier(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NestedNameSpecifier_getAsIdentifier_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifier arg;
arg = Clang_ext_nestednamespecifier_val(Field(arg_ocaml, 0));
CXString result = clang_ext_NestedNameSpecifier_getAsIdentifier(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NestedNameSpecifier_getAsNamespace_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifier arg;
arg = Clang_ext_nestednamespecifier_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_NestedNameSpecifier_getAsNamespace(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NestedNameSpecifier_getAsType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifier arg;
arg = Clang_ext_nestednamespecifier_val(Field(arg_ocaml, 0));
CXType result = clang_ext_NestedNameSpecifier_getAsType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
static void finalize_clang_ext_nestednamespecifierloc(value v) {
clang_ext_NestedNameSpecifierLoc_dispose(*((struct clang_ext_NestedNameSpecifierLoc *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_NestedNameSpecifierLoc, clang_ext_nestednamespecifierloc, Clang_ext_nestednamespecifierloc_val, Val_clang_ext_nestednamespecifierloc, finalize_clang_ext_nestednamespecifierloc, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_NestedNameSpecifierLoc_getNestedNameSpecifier_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifierLoc arg;
arg = Clang_ext_nestednamespecifierloc_val(Field(arg_ocaml, 0));
struct clang_ext_NestedNameSpecifier result = clang_ext_NestedNameSpecifierLoc_getNestedNameSpecifier(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_nestednamespecifier(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NestedNameSpecifierLoc_getPrefix_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifierLoc arg;
arg = Clang_ext_nestednamespecifierloc_val(Field(arg_ocaml, 0));
struct clang_ext_NestedNameSpecifierLoc result = clang_ext_NestedNameSpecifierLoc_getPrefix(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_nestednamespecifierloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NestedNameSpecifierLoc_getAsTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_NestedNameSpecifierLoc arg;
arg = Clang_ext_nestednamespecifierloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_NestedNameSpecifierLoc_getAsTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Decl_getNestedNameSpecifierLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_NestedNameSpecifierLoc result = clang_ext_Decl_getNestedNameSpecifierLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_nestednamespecifierloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeLoc_getQualifierLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_NestedNameSpecifierLoc result = clang_ext_TypeLoc_getQualifierLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_nestednamespecifierloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Type_getQualifier_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
struct clang_ext_NestedNameSpecifier result = clang_ext_Type_getQualifier(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_nestednamespecifier(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TagDecl_isCompleteDefinition_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_TagDecl_isCompleteDefinition(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXPseudoDestructorExpr_getDestroyedTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_CXXPseudoDestructorExpr_getDestroyedTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Cursor_getNumTemplateArgs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_Cursor_getNumTemplateArgs(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Cursor_getTemplateArg_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
struct clang_ext_TemplateArgument result = clang_ext_Cursor_getTemplateArg(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templateargument(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
static void finalize_clang_ext_templateparameterlist(value v) {
clang_ext_TemplateParameterList_dispose(*((struct clang_ext_TemplateParameterList *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_TemplateParameterList, clang_ext_templateparameterlist, Clang_ext_templateparameterlist_val, Val_clang_ext_templateparameterlist, finalize_clang_ext_templateparameterlist, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_TemplateParameterList_size_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateParameterList arg;
arg = Clang_ext_templateparameterlist_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_TemplateParameterList_size(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateParameterList_getParam_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
struct clang_ext_TemplateParameterList arg;
arg = Clang_ext_templateparameterlist_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_TemplateParameterList_getParam(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateParameterList_getRequiresClause_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TemplateParameterList arg;
arg = Clang_ext_templateparameterlist_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_TemplateParameterList_getRequiresClause(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateDecl_getTemplateParameters_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TemplateParameterList result = clang_ext_TemplateDecl_getTemplateParameters(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templateparameterlist(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateDecl_getParameterCount_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_TemplateDecl_getParameterCount(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TemplateDecl_getParameter_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_TemplateDecl_getParameter(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SubstNonTypeTemplateParmExpr_getReplacement_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_SubstNonTypeTemplateParmExpr_getReplacement(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AttributedStmt_GetAttributeCount_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_AttributedStmt_GetAttributeCount(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AttributedStmt_GetAttributeKind_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
enum clang_ext_AttrKind result = clang_ext_AttributedStmt_GetAttributeKind(arg, arg2);
{
CAMLlocal1(data);
data = Val_clang_ext_attrkind(result);
CAMLreturn(data);
}
}
void
clang_ext_AttributedStmt_getAttrs_arg2_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_AttributedStmt_getAttrs_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
clang_ext_AttributedStmt_getAttrs(arg, clang_ext_AttributedStmt_getAttrs_arg2_callback, (value *[]){&arg2_ocaml,&arg_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_DecompositionDecl_GetBindingsCount_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_DecompositionDecl_GetBindingsCount(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DecompositionDecl_GetBindings_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_DecompositionDecl_GetBindings(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attr_GetKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_AttrKind result = clang_ext_Attr_GetKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_attrkind(result);
CAMLreturn(data);
}
}
enum clang_ext_ExceptionSpecificationType
Clang_ext_exceptionspecificationtype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_EST_NoExceptionSpecification;
case 1: return CLANG_EXT_EST_DynamicNone;
case 2: return CLANG_EXT_EST_Dynamic;
case 3: return CLANG_EXT_EST_MSAny;
case 4: return CLANG_EXT_EST_NoThrow;
case 5: return CLANG_EXT_EST_BasicNoexcept;
case 6: return CLANG_EXT_EST_DependentNoexcept;
case 7: return CLANG_EXT_EST_NoexceptFalse;
case 8: return CLANG_EXT_EST_NoexceptTrue;
case 9: return CLANG_EXT_EST_Unevaluated;
case 10: return CLANG_EXT_EST_Uninstantiated;
case 11: return CLANG_EXT_EST_Unparsed;
}
caml_failwith_fmt("invalid value for Clang_ext_exceptionspecificationtype_val: %d", Int_val(ocaml));
return CLANG_EXT_EST_NoExceptionSpecification;
}
value
Val_clang_ext_exceptionspecificationtype(enum clang_ext_ExceptionSpecificationType v)
{
switch (v) {
case CLANG_EXT_EST_NoExceptionSpecification: return Val_int(0);
case CLANG_EXT_EST_DynamicNone: return Val_int(1);
case CLANG_EXT_EST_Dynamic: return Val_int(2);
case CLANG_EXT_EST_MSAny: return Val_int(3);
case CLANG_EXT_EST_NoThrow: return Val_int(4);
case CLANG_EXT_EST_BasicNoexcept: return Val_int(5);
case CLANG_EXT_EST_DependentNoexcept: return Val_int(6);
case CLANG_EXT_EST_NoexceptFalse: return Val_int(7);
case CLANG_EXT_EST_NoexceptTrue: return Val_int(8);
case CLANG_EXT_EST_Unevaluated: return Val_int(9);
case CLANG_EXT_EST_Uninstantiated: return Val_int(10);
case CLANG_EXT_EST_Unparsed: return Val_int(11);
}
caml_failwith_fmt("invalid value for Val_clang_ext_exceptionspecificationtype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_FunctionProtoType_getExceptionSpecType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
enum clang_ext_ExceptionSpecificationType result = clang_ext_FunctionProtoType_getExceptionSpecType(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_exceptionspecificationtype(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionProtoType_getNumExceptions_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_FunctionProtoType_getNumExceptions(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionProtoType_getExceptionType_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXType result = clang_ext_FunctionProtoType_getExceptionType(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionProtoType_getNoexceptExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_FunctionProtoType_getNoexceptExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmStmt_GetAsmString_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXString result = clang_ext_AsmStmt_GetAsmString(arg);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmStmt_getNumOutputs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_AsmStmt_getNumOutputs(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmStmt_getOutputConstraint_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXString result = clang_ext_AsmStmt_getOutputConstraint(arg, arg2);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmStmt_getOutputExpr_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_AsmStmt_getOutputExpr(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmStmt_getNumInputs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_AsmStmt_getNumInputs(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmStmt_getInputConstraint_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXString result = clang_ext_AsmStmt_getInputConstraint(arg, arg2);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmStmt_getInputExpr_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_AsmStmt_getInputExpr(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DeclaratorDecl_getTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_DeclaratorDecl_getTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_TypeLoc_Class
Clang_ext_typeloc_class_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_TYPELOC_Qualified;
case 1: return CLANG_EXT_TYPELOC_Adjusted;
case 2: return CLANG_EXT_TYPELOC_Decayed;
case 3: return CLANG_EXT_TYPELOC_ConstantArray;
case 4: return CLANG_EXT_TYPELOC_DependentSizedArray;
case 5: return CLANG_EXT_TYPELOC_IncompleteArray;
case 6: return CLANG_EXT_TYPELOC_VariableArray;
case 7: return CLANG_EXT_TYPELOC_Atomic;
case 8: return CLANG_EXT_TYPELOC_Attributed;
case 9: return CLANG_EXT_TYPELOC_BlockPointer;
case 10: return CLANG_EXT_TYPELOC_Builtin;
case 11: return CLANG_EXT_TYPELOC_Complex;
case 12: return CLANG_EXT_TYPELOC_Decltype;
case 13: return CLANG_EXT_TYPELOC_Auto;
case 14: return CLANG_EXT_TYPELOC_DeducedTemplateSpecialization;
case 15: return CLANG_EXT_TYPELOC_DependentAddressSpace;
case 16: return CLANG_EXT_TYPELOC_DependentExtInt;
case 17: return CLANG_EXT_TYPELOC_DependentName;
case 18: return CLANG_EXT_TYPELOC_DependentSizedExtVector;
case 19: return CLANG_EXT_TYPELOC_DependentTemplateSpecialization;
case 20: return CLANG_EXT_TYPELOC_DependentVector;
case 21: return CLANG_EXT_TYPELOC_Elaborated;
case 22: return CLANG_EXT_TYPELOC_ExtInt;
case 23: return CLANG_EXT_TYPELOC_FunctionNoProto;
case 24: return CLANG_EXT_TYPELOC_FunctionProto;
case 25: return CLANG_EXT_TYPELOC_InjectedClassName;
case 26: return CLANG_EXT_TYPELOC_MacroQualified;
case 27: return CLANG_EXT_TYPELOC_ConstantMatrix;
case 28: return CLANG_EXT_TYPELOC_DependentSizedMatrix;
case 29: return CLANG_EXT_TYPELOC_MemberPointer;
case 30: return CLANG_EXT_TYPELOC_ObjCObjectPointer;
case 31: return CLANG_EXT_TYPELOC_ObjCObject;
case 32: return CLANG_EXT_TYPELOC_ObjCInterface;
case 33: return CLANG_EXT_TYPELOC_ObjCTypeParam;
case 34: return CLANG_EXT_TYPELOC_PackExpansion;
case 35: return CLANG_EXT_TYPELOC_Paren;
case 36: return CLANG_EXT_TYPELOC_Pipe;
case 37: return CLANG_EXT_TYPELOC_Pointer;
case 38: return CLANG_EXT_TYPELOC_LValueReference;
case 39: return CLANG_EXT_TYPELOC_RValueReference;
case 40: return CLANG_EXT_TYPELOC_SubstTemplateTypeParmPack;
case 41: return CLANG_EXT_TYPELOC_SubstTemplateTypeParm;
case 42: return CLANG_EXT_TYPELOC_Enum;
case 43: return CLANG_EXT_TYPELOC_Record;
case 44: return CLANG_EXT_TYPELOC_TemplateSpecialization;
case 45: return CLANG_EXT_TYPELOC_TemplateTypeParm;
case 46: return CLANG_EXT_TYPELOC_TypeOfExpr;
case 47: return CLANG_EXT_TYPELOC_TypeOf;
case 48: return CLANG_EXT_TYPELOC_Typedef;
case 49: return CLANG_EXT_TYPELOC_UnaryTransform;
case 50: return CLANG_EXT_TYPELOC_UnresolvedUsing;
case 51: return CLANG_EXT_TYPELOC_Vector;
case 52: return CLANG_EXT_TYPELOC_ExtVector;
case 53: return CLANG_EXT_TYPELOC_InvalidTypeLoc;
}
caml_failwith_fmt("invalid value for Clang_ext_typeloc_class_val: %d", Int_val(ocaml));
return CLANG_EXT_TYPELOC_Qualified;
}
value
Val_clang_ext_typeloc_class(enum clang_ext_TypeLoc_Class v)
{
switch (v) {
case CLANG_EXT_TYPELOC_Qualified: return Val_int(0);
case CLANG_EXT_TYPELOC_Adjusted: return Val_int(1);
case CLANG_EXT_TYPELOC_Decayed: return Val_int(2);
case CLANG_EXT_TYPELOC_ConstantArray: return Val_int(3);
case CLANG_EXT_TYPELOC_DependentSizedArray: return Val_int(4);
case CLANG_EXT_TYPELOC_IncompleteArray: return Val_int(5);
case CLANG_EXT_TYPELOC_VariableArray: return Val_int(6);
case CLANG_EXT_TYPELOC_Atomic: return Val_int(7);
case CLANG_EXT_TYPELOC_Attributed: return Val_int(8);
case CLANG_EXT_TYPELOC_BlockPointer: return Val_int(9);
case CLANG_EXT_TYPELOC_Builtin: return Val_int(10);
case CLANG_EXT_TYPELOC_Complex: return Val_int(11);
case CLANG_EXT_TYPELOC_Decltype: return Val_int(12);
case CLANG_EXT_TYPELOC_Auto: return Val_int(13);
case CLANG_EXT_TYPELOC_DeducedTemplateSpecialization: return Val_int(14);
case CLANG_EXT_TYPELOC_DependentAddressSpace: return Val_int(15);
case CLANG_EXT_TYPELOC_DependentExtInt: return Val_int(16);
case CLANG_EXT_TYPELOC_DependentName: return Val_int(17);
case CLANG_EXT_TYPELOC_DependentSizedExtVector: return Val_int(18);
case CLANG_EXT_TYPELOC_DependentTemplateSpecialization: return Val_int(19);
case CLANG_EXT_TYPELOC_DependentVector: return Val_int(20);
case CLANG_EXT_TYPELOC_Elaborated: return Val_int(21);
case CLANG_EXT_TYPELOC_ExtInt: return Val_int(22);
case CLANG_EXT_TYPELOC_FunctionNoProto: return Val_int(23);
case CLANG_EXT_TYPELOC_FunctionProto: return Val_int(24);
case CLANG_EXT_TYPELOC_InjectedClassName: return Val_int(25);
case CLANG_EXT_TYPELOC_MacroQualified: return Val_int(26);
case CLANG_EXT_TYPELOC_ConstantMatrix: return Val_int(27);
case CLANG_EXT_TYPELOC_DependentSizedMatrix: return Val_int(28);
case CLANG_EXT_TYPELOC_MemberPointer: return Val_int(29);
case CLANG_EXT_TYPELOC_ObjCObjectPointer: return Val_int(30);
case CLANG_EXT_TYPELOC_ObjCObject: return Val_int(31);
case CLANG_EXT_TYPELOC_ObjCInterface: return Val_int(32);
case CLANG_EXT_TYPELOC_ObjCTypeParam: return Val_int(33);
case CLANG_EXT_TYPELOC_PackExpansion: return Val_int(34);
case CLANG_EXT_TYPELOC_Paren: return Val_int(35);
case CLANG_EXT_TYPELOC_Pipe: return Val_int(36);
case CLANG_EXT_TYPELOC_Pointer: return Val_int(37);
case CLANG_EXT_TYPELOC_LValueReference: return Val_int(38);
case CLANG_EXT_TYPELOC_RValueReference: return Val_int(39);
case CLANG_EXT_TYPELOC_SubstTemplateTypeParmPack: return Val_int(40);
case CLANG_EXT_TYPELOC_SubstTemplateTypeParm: return Val_int(41);
case CLANG_EXT_TYPELOC_Enum: return Val_int(42);
case CLANG_EXT_TYPELOC_Record: return Val_int(43);
case CLANG_EXT_TYPELOC_TemplateSpecialization: return Val_int(44);
case CLANG_EXT_TYPELOC_TemplateTypeParm: return Val_int(45);
case CLANG_EXT_TYPELOC_TypeOfExpr: return Val_int(46);
case CLANG_EXT_TYPELOC_TypeOf: return Val_int(47);
case CLANG_EXT_TYPELOC_Typedef: return Val_int(48);
case CLANG_EXT_TYPELOC_UnaryTransform: return Val_int(49);
case CLANG_EXT_TYPELOC_UnresolvedUsing: return Val_int(50);
case CLANG_EXT_TYPELOC_Vector: return Val_int(51);
case CLANG_EXT_TYPELOC_ExtVector: return Val_int(52);
case CLANG_EXT_TYPELOC_InvalidTypeLoc: return Val_int(53);
}
caml_failwith_fmt("invalid value for Val_clang_ext_typeloc_class: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TypeLoc_getClass_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
enum clang_ext_TypeLoc_Class result = clang_ext_TypeLoc_getClass(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_typeloc_class(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeLoc_getType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
CXType result = clang_ext_TypeLoc_getType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ArrayTypeLoc_getSizeExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_ArrayTypeLoc_getSizeExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ArrayTypeLoc_getElementLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_ArrayTypeLoc_getElementLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ParenTypeLoc_getInnerLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_ParenTypeLoc_getInnerLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PointerLikeTypeLoc_getPointeeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_PointerLikeTypeLoc_getPointeeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_MemberPointerTypeLoc_getClassLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_MemberPointerTypeLoc_getClassLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_QualifiedTypeLoc_getUnqualifiedLoc_wrapper(value tl_ocaml)
{
CAMLparam1(tl_ocaml);
struct clang_ext_TypeLoc tl;
tl = Clang_ext_typeloc_val(Field(tl_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_QualifiedTypeLoc_getUnqualifiedLoc(tl);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(tl_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionTypeLoc_getReturnLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_FunctionTypeLoc_getReturnLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionTypeLoc_getNumParams_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_FunctionTypeLoc_getNumParams(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionTypeLoc_getParam_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_FunctionTypeLoc_getParam(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_InitListExpr_getSyntacticForm_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_InitListExpr_getSyntacticForm(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_InitListExpr_getSemanticForm_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_InitListExpr_getSemanticForm(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_InitListExpr_getNumInits_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_InitListExpr_getNumInits(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_InitListExpr_getInit_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_InitListExpr_getInit(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DesignatedInitExpr_size_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_DesignatedInitExpr_size(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_DesignatedInitExpr_DesignatorKind
Clang_ext_designatedinitexpr_designatorkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_FieldDesignator;
case 1: return clang_ext_ArrayDesignator;
case 2: return clang_ext_ArrayRangeDesignator;
}
caml_failwith_fmt("invalid value for Clang_ext_designatedinitexpr_designatorkind_val: %d", Int_val(ocaml));
return clang_ext_FieldDesignator;
}
value
Val_clang_ext_designatedinitexpr_designatorkind(enum clang_ext_DesignatedInitExpr_DesignatorKind v)
{
switch (v) {
case clang_ext_FieldDesignator: return Val_int(0);
case clang_ext_ArrayDesignator: return Val_int(1);
case clang_ext_ArrayRangeDesignator: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_designatedinitexpr_designatorkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_DesignatedInitExpr_getKind_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
enum clang_ext_DesignatedInitExpr_DesignatorKind result = clang_ext_DesignatedInitExpr_getKind(arg, arg2);
{
CAMLlocal1(data);
data = Val_clang_ext_designatedinitexpr_designatorkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DesignatedInitExpr_getField_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_DesignatedInitExpr_getField(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DesignatedInitExpr_getArrayIndex_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_DesignatedInitExpr_getArrayIndex(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DesignatedInitExpr_getArrayRangeStart_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_DesignatedInitExpr_getArrayRangeStart(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DesignatedInitExpr_getArrayRangeEnd_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_DesignatedInitExpr_getArrayRangeEnd(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DesignatedInitExpr_getInit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_DesignatedInitExpr_getInit(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ConceptDecl_getConstraintExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_ConceptDecl_getConstraintExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_RequirementKind
Clang_ext_requirementkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_RK_Type;
case 1: return clang_ext_RK_Simple;
case 2: return clang_ext_RK_Compound;
case 3: return clang_ext_RK_Nested;
}
caml_failwith_fmt("invalid value for Clang_ext_requirementkind_val: %d", Int_val(ocaml));
return clang_ext_RK_Type;
}
value
Val_clang_ext_requirementkind(enum clang_ext_RequirementKind v)
{
switch (v) {
case clang_ext_RK_Type: return Val_int(0);
case clang_ext_RK_Simple: return Val_int(1);
case clang_ext_RK_Compound: return Val_int(2);
case clang_ext_RK_Nested: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_requirementkind: %d", v);
return Val_int(0);
}
static void finalize_clang_ext_requirement(value v) {
clang_ext_Requirement_dispose(*((struct clang_ext_Requirement *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_Requirement, clang_ext_requirement, Clang_ext_requirement_val, Val_clang_ext_requirement, finalize_clang_ext_requirement, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_Requirement_getKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_Requirement arg;
arg = Clang_ext_requirement_val(Field(arg_ocaml, 0));
enum clang_ext_RequirementKind result = clang_ext_Requirement_getKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_requirementkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeRequirement_getType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_Requirement arg;
arg = Clang_ext_requirement_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_TypeRequirement_getType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExprRequirement_getExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_Requirement arg;
arg = Clang_ext_requirement_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_ExprRequirement_getExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExprRequirement_ReturnType_getTypeConstraintTemplateParameterList_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_Requirement arg;
arg = Clang_ext_requirement_val(Field(arg_ocaml, 0));
struct clang_ext_TemplateParameterList result = clang_ext_ExprRequirement_ReturnType_getTypeConstraintTemplateParameterList(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templateparameterlist(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExprRequirement_ReturnType_getTypeConstraint_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_Requirement arg;
arg = Clang_ext_requirement_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_ExprRequirement_ReturnType_getTypeConstraint(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NestedRequirement_getConstraintExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_Requirement arg;
arg = Clang_ext_requirement_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_NestedRequirement_getConstraintExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_RequiresExpr_getLocalParameterCount_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_RequiresExpr_getLocalParameterCount(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_RequiresExpr_getLocalParameter_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_RequiresExpr_getLocalParameter(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_RequiresExpr_getRequirementCount_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_RequiresExpr_getRequirementCount(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_RequiresExpr_getRequirement_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
struct clang_ext_Requirement result = clang_ext_RequiresExpr_getRequirement(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_requirement(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum CXChildVisitResult
clang_ext_DeclContext_visitDecls_visitor_callback(CXCursor arg0, CXCursor arg1, CXClientData arg2)
{
CAMLparam0();
CAMLlocal4(result, f, arg0_ocaml, arg1_ocaml);
f = *((value *) ((value **)arg2)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg2)[1], 1));arg1_ocaml = caml_alloc_tuple(2);
Store_field(arg1_ocaml, 0, Val_cxcursor(arg1));
Store_field(arg1_ocaml, 1, safe_field(*((value **)arg2)[1], 1)); result = caml_callback2(f, arg0_ocaml, arg1_ocaml);
{
CAMLlocal1(data);
data = Cxchildvisitresult_val(result);
CAMLreturnT(enum CXChildVisitResult, data);
}
}
CAMLprim value
clang_ext_DeclContext_visitDecls_wrapper(value parent_ocaml, value visitor_ocaml)
{
CAMLparam2(parent_ocaml, visitor_ocaml);
CXCursor parent;
parent = Cxcursor_val(Field(parent_ocaml, 0));
unsigned int result = clang_ext_DeclContext_visitDecls(parent, clang_ext_DeclContext_visitDecls_visitor_callback, (value *[]){&visitor_ocaml,&parent_ocaml});
{
CAMLlocal1(data);
data = Val_not_bool(result);
CAMLreturn(data);
}
}
enum CXChildVisitResult
clang_ext_IndirectFieldDecl_visitChain_visitor_callback(CXCursor arg0, CXCursor arg1, CXClientData arg2)
{
CAMLparam0();
CAMLlocal4(result, f, arg0_ocaml, arg1_ocaml);
f = *((value *) ((value **)arg2)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg2)[1], 1));arg1_ocaml = caml_alloc_tuple(2);
Store_field(arg1_ocaml, 0, Val_cxcursor(arg1));
Store_field(arg1_ocaml, 1, safe_field(*((value **)arg2)[1], 1)); result = caml_callback2(f, arg0_ocaml, arg1_ocaml);
{
CAMLlocal1(data);
data = Cxchildvisitresult_val(result);
CAMLreturnT(enum CXChildVisitResult, data);
}
}
CAMLprim value
clang_ext_IndirectFieldDecl_visitChain_wrapper(value parent_ocaml, value visitor_ocaml)
{
CAMLparam2(parent_ocaml, visitor_ocaml);
CXCursor parent;
parent = Cxcursor_val(Field(parent_ocaml, 0));
unsigned int result = clang_ext_IndirectFieldDecl_visitChain(parent, clang_ext_IndirectFieldDecl_visitChain_visitor_callback, (value *[]){&visitor_ocaml,&parent_ocaml});
{
CAMLlocal1(data);
data = Val_not_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TagDecl_getTagKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_ElaboratedTypeKeyword result = clang_ext_TagDecl_getTagKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_elaboratedtypekeyword(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Decl_hasAttrs_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_Decl_hasAttrs(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Decl_getAttrCount_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_Decl_getAttrCount(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Decl_getAttr_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
CXCursor result = clang_ext_Decl_getAttr(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CursorKind_isAttr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
enum CXCursorKind arg;
arg = Cxcursorkind_val(arg_ocaml);
_Bool result = clang_ext_CursorKind_isAttr(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_isInlineSpecified_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_FunctionDecl_isInlineSpecified(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_isInlined_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_FunctionDecl_isInlined(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Cursor_getTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_Cursor_getTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXForRangeStmt_getLoopVariable_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXForRangeStmt_getLoopVariable(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXForRangeStmt_getRangeInit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXForRangeStmt_getRangeInit(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXForRangeStmt_getBody_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXForRangeStmt_getBody(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AttributedTypeLoc_getModifiedLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_AttributedTypeLoc_getModifiedLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AttributedTypeLoc_getAttr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_AttributedTypeLoc_getAttr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AttributedType_getModifiedType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXType result = clang_ext_AttributedType_getModifiedType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AttributedType_getAttrKind_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
enum clang_ext_AttrKind result = clang_ext_AttributedType_getAttrKind(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_attrkind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ElaboratedTypeLoc_getNamedTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_ElaboratedTypeLoc_getNamedTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PackExpansionTypeLoc_getPatternLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_PackExpansionTypeLoc_getPatternLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypedefDecl_getUnderlyingTypeLoc_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_TypedefDecl_getUnderlyingTypeLoc(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXMethodDecl_getParent_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXMethodDecl_getParent(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_InjectedClassNameType_getInjectedSpecializationType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXType result = clang_ext_InjectedClassNameType_getInjectedSpecializationType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Type_getUnqualifiedType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXType result = clang_ext_Type_getUnqualifiedType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Type_isSugared_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_Type_isSugared(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Type_desugar_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXType result = clang_ext_Type_desugar(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
static void finalize_clang_ext_cxxctorinitializer(value v) {
clang_ext_CXXCtorInitializer_dispose(*((struct clang_ext_CXXCtorInitializer *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_CXXCtorInitializer, clang_ext_cxxctorinitializer, Clang_ext_cxxctorinitializer_val, Val_clang_ext_cxxctorinitializer, finalize_clang_ext_cxxctorinitializer, custom_compare_default, custom_hash_default)
enum CXVisitorResult
clang_ext_CXXConstructorDecl_visitInitializers_visitor_callback(struct clang_ext_CXXCtorInitializer arg0, CXClientData arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_clang_ext_cxxctorinitializer(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); result = caml_callback(f, arg0_ocaml);
{
CAMLlocal1(data);
data = Cxvisitorresult_val(result);
CAMLreturnT(enum CXVisitorResult, data);
}
}
CAMLprim value
clang_ext_CXXConstructorDecl_visitInitializers_wrapper(value parent_ocaml, value visitor_ocaml)
{
CAMLparam2(parent_ocaml, visitor_ocaml);
CXCursor parent;
parent = Cxcursor_val(Field(parent_ocaml, 0));
unsigned int result = clang_ext_CXXConstructorDecl_visitInitializers(parent, clang_ext_CXXConstructorDecl_visitInitializers_visitor_callback, (value *[]){&visitor_ocaml,&parent_ocaml});
{
CAMLlocal1(data);
data = Val_not_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_isBaseInitializer_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXCtorInitializer_isBaseInitializer(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_isPackExpansion_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXCtorInitializer_isPackExpansion(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_isMemberInitializer_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXCtorInitializer_isMemberInitializer(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_isIndirectMemberInitializer_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXCtorInitializer_isIndirectMemberInitializer(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_isDelegatingInitializer_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
_Bool result = clang_ext_CXXCtorInitializer_isDelegatingInitializer(arg);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_getTypeSourceInfo_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_CXXCtorInitializer_getTypeSourceInfo(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_getMember_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXCtorInitializer_getMember(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_getAnyMember_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXCtorInitializer_getAnyMember(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CXXCtorInitializer_getInit_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_CXXCtorInitializer arg;
arg = Clang_ext_cxxctorinitializer_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_CXXCtorInitializer_getInit(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_getNumTemplateParameterLists_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int result = clang_ext_FunctionDecl_getNumTemplateParameterLists(arg);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FunctionDecl_getTemplateParameterList_wrapper(value arg_ocaml, value arg2_ocaml)
{
CAMLparam2(arg_ocaml, arg2_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
unsigned int arg2;
arg2 = Int_val(arg2_ocaml);
struct clang_ext_TemplateParameterList result = clang_ext_FunctionDecl_getTemplateParameterList(arg, arg2);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_templateparameterlist(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AtomicType_getValueType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXType result = clang_ext_AtomicType_getValueType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_expr_AtomicOp
Clang_expr_atomicop_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_AO_Invalid;
case 1: return CLANG_EXT_AO__c11_atomic_init;
case 2: return CLANG_EXT_AO__c11_atomic_load;
case 3: return CLANG_EXT_AO__c11_atomic_store;
case 4: return CLANG_EXT_AO__c11_atomic_exchange;
case 5: return CLANG_EXT_AO__c11_atomic_compare_exchange_strong;
case 6: return CLANG_EXT_AO__c11_atomic_compare_exchange_weak;
case 7: return CLANG_EXT_AO__c11_atomic_fetch_add;
case 8: return CLANG_EXT_AO__c11_atomic_fetch_sub;
case 9: return CLANG_EXT_AO__c11_atomic_fetch_and;
case 10: return CLANG_EXT_AO__c11_atomic_fetch_or;
case 11: return CLANG_EXT_AO__c11_atomic_fetch_xor;
case 12: return CLANG_EXT_AO__c11_atomic_fetch_max;
case 13: return CLANG_EXT_AO__c11_atomic_fetch_min;
case 14: return CLANG_EXT_AO__atomic_load;
case 15: return CLANG_EXT_AO__atomic_load_n;
case 16: return CLANG_EXT_AO__atomic_store;
case 17: return CLANG_EXT_AO__atomic_store_n;
case 18: return CLANG_EXT_AO__atomic_exchange;
case 19: return CLANG_EXT_AO__atomic_exchange_n;
case 20: return CLANG_EXT_AO__atomic_compare_exchange;
case 21: return CLANG_EXT_AO__atomic_compare_exchange_n;
case 22: return CLANG_EXT_AO__atomic_fetch_add;
case 23: return CLANG_EXT_AO__atomic_fetch_sub;
case 24: return CLANG_EXT_AO__atomic_fetch_and;
case 25: return CLANG_EXT_AO__atomic_fetch_or;
case 26: return CLANG_EXT_AO__atomic_fetch_xor;
case 27: return CLANG_EXT_AO__atomic_fetch_nand;
case 28: return CLANG_EXT_AO__atomic_add_fetch;
case 29: return CLANG_EXT_AO__atomic_sub_fetch;
case 30: return CLANG_EXT_AO__atomic_and_fetch;
case 31: return CLANG_EXT_AO__atomic_or_fetch;
case 32: return CLANG_EXT_AO__atomic_xor_fetch;
case 33: return CLANG_EXT_AO__atomic_max_fetch;
case 34: return CLANG_EXT_AO__atomic_min_fetch;
case 35: return CLANG_EXT_AO__atomic_nand_fetch;
case 36: return CLANG_EXT_AO__opencl_atomic_init;
case 37: return CLANG_EXT_AO__opencl_atomic_load;
case 38: return CLANG_EXT_AO__opencl_atomic_store;
case 39: return CLANG_EXT_AO__opencl_atomic_exchange;
case 40: return CLANG_EXT_AO__opencl_atomic_compare_exchange_strong;
case 41: return CLANG_EXT_AO__opencl_atomic_compare_exchange_weak;
case 42: return CLANG_EXT_AO__opencl_atomic_fetch_add;
case 43: return CLANG_EXT_AO__opencl_atomic_fetch_sub;
case 44: return CLANG_EXT_AO__opencl_atomic_fetch_and;
case 45: return CLANG_EXT_AO__opencl_atomic_fetch_or;
case 46: return CLANG_EXT_AO__opencl_atomic_fetch_xor;
case 47: return CLANG_EXT_AO__opencl_atomic_fetch_min;
case 48: return CLANG_EXT_AO__opencl_atomic_fetch_max;
case 49: return CLANG_EXT_AO__atomic_fetch_min;
case 50: return CLANG_EXT_AO__atomic_fetch_max;
}
caml_failwith_fmt("invalid value for Clang_expr_atomicop_val: %d", Int_val(ocaml));
return CLANG_EXT_AO_Invalid;
}
value
Val_clang_expr_atomicop(enum clang_expr_AtomicOp v)
{
switch (v) {
case CLANG_EXT_AO_Invalid: return Val_int(0);
case CLANG_EXT_AO__c11_atomic_init: return Val_int(1);
case CLANG_EXT_AO__c11_atomic_load: return Val_int(2);
case CLANG_EXT_AO__c11_atomic_store: return Val_int(3);
case CLANG_EXT_AO__c11_atomic_exchange: return Val_int(4);
case CLANG_EXT_AO__c11_atomic_compare_exchange_strong: return Val_int(5);
case CLANG_EXT_AO__c11_atomic_compare_exchange_weak: return Val_int(6);
case CLANG_EXT_AO__c11_atomic_fetch_add: return Val_int(7);
case CLANG_EXT_AO__c11_atomic_fetch_sub: return Val_int(8);
case CLANG_EXT_AO__c11_atomic_fetch_and: return Val_int(9);
case CLANG_EXT_AO__c11_atomic_fetch_or: return Val_int(10);
case CLANG_EXT_AO__c11_atomic_fetch_xor: return Val_int(11);
case CLANG_EXT_AO__c11_atomic_fetch_max: return Val_int(12);
case CLANG_EXT_AO__c11_atomic_fetch_min: return Val_int(13);
case CLANG_EXT_AO__atomic_load: return Val_int(14);
case CLANG_EXT_AO__atomic_load_n: return Val_int(15);
case CLANG_EXT_AO__atomic_store: return Val_int(16);
case CLANG_EXT_AO__atomic_store_n: return Val_int(17);
case CLANG_EXT_AO__atomic_exchange: return Val_int(18);
case CLANG_EXT_AO__atomic_exchange_n: return Val_int(19);
case CLANG_EXT_AO__atomic_compare_exchange: return Val_int(20);
case CLANG_EXT_AO__atomic_compare_exchange_n: return Val_int(21);
case CLANG_EXT_AO__atomic_fetch_add: return Val_int(22);
case CLANG_EXT_AO__atomic_fetch_sub: return Val_int(23);
case CLANG_EXT_AO__atomic_fetch_and: return Val_int(24);
case CLANG_EXT_AO__atomic_fetch_or: return Val_int(25);
case CLANG_EXT_AO__atomic_fetch_xor: return Val_int(26);
case CLANG_EXT_AO__atomic_fetch_nand: return Val_int(27);
case CLANG_EXT_AO__atomic_add_fetch: return Val_int(28);
case CLANG_EXT_AO__atomic_sub_fetch: return Val_int(29);
case CLANG_EXT_AO__atomic_and_fetch: return Val_int(30);
case CLANG_EXT_AO__atomic_or_fetch: return Val_int(31);
case CLANG_EXT_AO__atomic_xor_fetch: return Val_int(32);
case CLANG_EXT_AO__atomic_max_fetch: return Val_int(33);
case CLANG_EXT_AO__atomic_min_fetch: return Val_int(34);
case CLANG_EXT_AO__atomic_nand_fetch: return Val_int(35);
case CLANG_EXT_AO__opencl_atomic_init: return Val_int(36);
case CLANG_EXT_AO__opencl_atomic_load: return Val_int(37);
case CLANG_EXT_AO__opencl_atomic_store: return Val_int(38);
case CLANG_EXT_AO__opencl_atomic_exchange: return Val_int(39);
case CLANG_EXT_AO__opencl_atomic_compare_exchange_strong: return Val_int(40);
case CLANG_EXT_AO__opencl_atomic_compare_exchange_weak: return Val_int(41);
case CLANG_EXT_AO__opencl_atomic_fetch_add: return Val_int(42);
case CLANG_EXT_AO__opencl_atomic_fetch_sub: return Val_int(43);
case CLANG_EXT_AO__opencl_atomic_fetch_and: return Val_int(44);
case CLANG_EXT_AO__opencl_atomic_fetch_or: return Val_int(45);
case CLANG_EXT_AO__opencl_atomic_fetch_xor: return Val_int(46);
case CLANG_EXT_AO__opencl_atomic_fetch_min: return Val_int(47);
case CLANG_EXT_AO__opencl_atomic_fetch_max: return Val_int(48);
case CLANG_EXT_AO__atomic_fetch_min: return Val_int(49);
case CLANG_EXT_AO__atomic_fetch_max: return Val_int(50);
}
caml_failwith_fmt("invalid value for Val_clang_expr_atomicop: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AtomicExpr_getOp_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_expr_AtomicOp result = clang_ext_AtomicExpr_getOp(arg);
{
CAMLlocal1(data);
data = Val_clang_expr_atomicop(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeOfExprType_getUnderlyingExpr_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXCursor result = clang_ext_TypeOfExprType_getUnderlyingExpr(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeOfType_getUnderlyingType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXType arg;
arg = Cxtype_val(Field(arg_ocaml, 0));
CXType result = clang_ext_TypeOfType_getUnderlyingType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxtype(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeOfTypeLoc_getUnderlyingType_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
struct clang_ext_TypeLoc arg;
arg = Clang_ext_typeloc_val(Field(arg_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_TypeOfTypeLoc_getUnderlyingType(arg);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(arg_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_StorageClass
Clang_ext_storageclass_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return CLANG_EXT_SC_None;
case 1: return CLANG_EXT_SC_Extern;
case 2: return CLANG_EXT_SC_Static;
case 3: return CLANG_EXT_SC_PrivateExtern;
case 4: return CLANG_EXT_SC_OpenCLWorkGroupLocal;
case 5: return CLANG_EXT_SC_Auto;
case 6: return CLANG_EXT_SC_Register;
}
caml_failwith_fmt("invalid value for Clang_ext_storageclass_val: %d", Int_val(ocaml));
return CLANG_EXT_SC_None;
}
value
Val_clang_ext_storageclass(enum clang_ext_StorageClass v)
{
switch (v) {
case CLANG_EXT_SC_None: return Val_int(0);
case CLANG_EXT_SC_Extern: return Val_int(1);
case CLANG_EXT_SC_Static: return Val_int(2);
case CLANG_EXT_SC_PrivateExtern: return Val_int(3);
case CLANG_EXT_SC_OpenCLWorkGroupLocal: return Val_int(4);
case CLANG_EXT_SC_Auto: return Val_int(5);
case CLANG_EXT_SC_Register: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_storageclass: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Decl_getStorageClass_wrapper(value arg_ocaml)
{
CAMLparam1(arg_ocaml);
CXCursor arg;
arg = Cxcursor_val(Field(arg_ocaml, 0));
enum clang_ext_StorageClass result = clang_ext_Decl_getStorageClass(arg);
{
CAMLlocal1(data);
data = Val_clang_ext_storageclass(result);
CAMLreturn(data);
}
}
enum clang_ext_AArch64SVEPcs_spelling
Clang_ext_aarch64svepcs_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AArch64SVEPcs_GNU_aarch64_sve_pcs;
case 1: return clang_ext_AArch64SVEPcs_CXX11_clang_aarch64_sve_pcs;
case 2: return clang_ext_AArch64SVEPcs_C2x_clang_aarch64_sve_pcs;
case 3: return clang_ext_AArch64SVEPcs_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_aarch64svepcs_spelling_val: %d", Int_val(ocaml));
return clang_ext_AArch64SVEPcs_GNU_aarch64_sve_pcs;
}
value
Val_clang_ext_aarch64svepcs_spelling(enum clang_ext_AArch64SVEPcs_spelling v)
{
switch (v) {
case clang_ext_AArch64SVEPcs_GNU_aarch64_sve_pcs: return Val_int(0);
case clang_ext_AArch64SVEPcs_CXX11_clang_aarch64_sve_pcs: return Val_int(1);
case clang_ext_AArch64SVEPcs_C2x_clang_aarch64_sve_pcs: return Val_int(2);
case clang_ext_AArch64SVEPcs_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_aarch64svepcs_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AArch64SVEPcs_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AArch64SVEPcs_spelling result = clang_ext_AArch64SVEPcs_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_aarch64svepcs_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AArch64VectorPcs_spelling
Clang_ext_aarch64vectorpcs_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AArch64VectorPcs_GNU_aarch64_vector_pcs;
case 1: return clang_ext_AArch64VectorPcs_CXX11_clang_aarch64_vector_pcs;
case 2: return clang_ext_AArch64VectorPcs_C2x_clang_aarch64_vector_pcs;
case 3: return clang_ext_AArch64VectorPcs_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_aarch64vectorpcs_spelling_val: %d", Int_val(ocaml));
return clang_ext_AArch64VectorPcs_GNU_aarch64_vector_pcs;
}
value
Val_clang_ext_aarch64vectorpcs_spelling(enum clang_ext_AArch64VectorPcs_spelling v)
{
switch (v) {
case clang_ext_AArch64VectorPcs_GNU_aarch64_vector_pcs: return Val_int(0);
case clang_ext_AArch64VectorPcs_CXX11_clang_aarch64_vector_pcs: return Val_int(1);
case clang_ext_AArch64VectorPcs_C2x_clang_aarch64_vector_pcs: return Val_int(2);
case clang_ext_AArch64VectorPcs_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_aarch64vectorpcs_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AArch64VectorPcs_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AArch64VectorPcs_spelling result = clang_ext_AArch64VectorPcs_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_aarch64vectorpcs_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AMDGPUFlatWorkGroupSize_spelling
Clang_ext_amdgpuflatworkgroupsize_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AMDGPUFlatWorkGroupSize_GNU_amdgpu_flat_work_group_size;
case 1: return clang_ext_AMDGPUFlatWorkGroupSize_CXX11_clang_amdgpu_flat_work_group_size;
case 2: return clang_ext_AMDGPUFlatWorkGroupSize_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_amdgpuflatworkgroupsize_spelling_val: %d", Int_val(ocaml));
return clang_ext_AMDGPUFlatWorkGroupSize_GNU_amdgpu_flat_work_group_size;
}
value
Val_clang_ext_amdgpuflatworkgroupsize_spelling(enum clang_ext_AMDGPUFlatWorkGroupSize_spelling v)
{
switch (v) {
case clang_ext_AMDGPUFlatWorkGroupSize_GNU_amdgpu_flat_work_group_size: return Val_int(0);
case clang_ext_AMDGPUFlatWorkGroupSize_CXX11_clang_amdgpu_flat_work_group_size: return Val_int(1);
case clang_ext_AMDGPUFlatWorkGroupSize_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_amdgpuflatworkgroupsize_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AMDGPUFlatWorkGroupSize_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AMDGPUFlatWorkGroupSize_spelling result = clang_ext_AMDGPUFlatWorkGroupSize_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_amdgpuflatworkgroupsize_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AMDGPUKernelCall_spelling
Clang_ext_amdgpukernelcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AMDGPUKernelCall_GNU_amdgpu_kernel;
case 1: return clang_ext_AMDGPUKernelCall_CXX11_clang_amdgpu_kernel;
case 2: return clang_ext_AMDGPUKernelCall_C2x_clang_amdgpu_kernel;
case 3: return clang_ext_AMDGPUKernelCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_amdgpukernelcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_AMDGPUKernelCall_GNU_amdgpu_kernel;
}
value
Val_clang_ext_amdgpukernelcall_spelling(enum clang_ext_AMDGPUKernelCall_spelling v)
{
switch (v) {
case clang_ext_AMDGPUKernelCall_GNU_amdgpu_kernel: return Val_int(0);
case clang_ext_AMDGPUKernelCall_CXX11_clang_amdgpu_kernel: return Val_int(1);
case clang_ext_AMDGPUKernelCall_C2x_clang_amdgpu_kernel: return Val_int(2);
case clang_ext_AMDGPUKernelCall_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_amdgpukernelcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AMDGPUKernelCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AMDGPUKernelCall_spelling result = clang_ext_AMDGPUKernelCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_amdgpukernelcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AMDGPUNumSGPR_spelling
Clang_ext_amdgpunumsgpr_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AMDGPUNumSGPR_GNU_amdgpu_num_sgpr;
case 1: return clang_ext_AMDGPUNumSGPR_CXX11_clang_amdgpu_num_sgpr;
case 2: return clang_ext_AMDGPUNumSGPR_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_amdgpunumsgpr_spelling_val: %d", Int_val(ocaml));
return clang_ext_AMDGPUNumSGPR_GNU_amdgpu_num_sgpr;
}
value
Val_clang_ext_amdgpunumsgpr_spelling(enum clang_ext_AMDGPUNumSGPR_spelling v)
{
switch (v) {
case clang_ext_AMDGPUNumSGPR_GNU_amdgpu_num_sgpr: return Val_int(0);
case clang_ext_AMDGPUNumSGPR_CXX11_clang_amdgpu_num_sgpr: return Val_int(1);
case clang_ext_AMDGPUNumSGPR_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_amdgpunumsgpr_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AMDGPUNumSGPR_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AMDGPUNumSGPR_spelling result = clang_ext_AMDGPUNumSGPR_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_amdgpunumsgpr_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AMDGPUNumVGPR_spelling
Clang_ext_amdgpunumvgpr_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AMDGPUNumVGPR_GNU_amdgpu_num_vgpr;
case 1: return clang_ext_AMDGPUNumVGPR_CXX11_clang_amdgpu_num_vgpr;
case 2: return clang_ext_AMDGPUNumVGPR_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_amdgpunumvgpr_spelling_val: %d", Int_val(ocaml));
return clang_ext_AMDGPUNumVGPR_GNU_amdgpu_num_vgpr;
}
value
Val_clang_ext_amdgpunumvgpr_spelling(enum clang_ext_AMDGPUNumVGPR_spelling v)
{
switch (v) {
case clang_ext_AMDGPUNumVGPR_GNU_amdgpu_num_vgpr: return Val_int(0);
case clang_ext_AMDGPUNumVGPR_CXX11_clang_amdgpu_num_vgpr: return Val_int(1);
case clang_ext_AMDGPUNumVGPR_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_amdgpunumvgpr_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AMDGPUNumVGPR_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AMDGPUNumVGPR_spelling result = clang_ext_AMDGPUNumVGPR_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_amdgpunumvgpr_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AMDGPUWavesPerEU_spelling
Clang_ext_amdgpuwavespereu_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AMDGPUWavesPerEU_GNU_amdgpu_waves_per_eu;
case 1: return clang_ext_AMDGPUWavesPerEU_CXX11_clang_amdgpu_waves_per_eu;
case 2: return clang_ext_AMDGPUWavesPerEU_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_amdgpuwavespereu_spelling_val: %d", Int_val(ocaml));
return clang_ext_AMDGPUWavesPerEU_GNU_amdgpu_waves_per_eu;
}
value
Val_clang_ext_amdgpuwavespereu_spelling(enum clang_ext_AMDGPUWavesPerEU_spelling v)
{
switch (v) {
case clang_ext_AMDGPUWavesPerEU_GNU_amdgpu_waves_per_eu: return Val_int(0);
case clang_ext_AMDGPUWavesPerEU_CXX11_clang_amdgpu_waves_per_eu: return Val_int(1);
case clang_ext_AMDGPUWavesPerEU_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_amdgpuwavespereu_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AMDGPUWavesPerEU_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AMDGPUWavesPerEU_spelling result = clang_ext_AMDGPUWavesPerEU_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_amdgpuwavespereu_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ARMInterrupt_spelling
Clang_ext_arminterrupt_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ARMInterrupt_GNU_interrupt;
case 1: return clang_ext_ARMInterrupt_CXX11_gnu_interrupt;
case 2: return clang_ext_ARMInterrupt_C2x_gnu_interrupt;
case 3: return clang_ext_ARMInterrupt_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_arminterrupt_spelling_val: %d", Int_val(ocaml));
return clang_ext_ARMInterrupt_GNU_interrupt;
}
value
Val_clang_ext_arminterrupt_spelling(enum clang_ext_ARMInterrupt_spelling v)
{
switch (v) {
case clang_ext_ARMInterrupt_GNU_interrupt: return Val_int(0);
case clang_ext_ARMInterrupt_CXX11_gnu_interrupt: return Val_int(1);
case clang_ext_ARMInterrupt_C2x_gnu_interrupt: return Val_int(2);
case clang_ext_ARMInterrupt_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_arminterrupt_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ARMInterrupt_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ARMInterrupt_spelling result = clang_ext_ARMInterrupt_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_arminterrupt_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AVRInterrupt_spelling
Clang_ext_avrinterrupt_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AVRInterrupt_GNU_interrupt;
case 1: return clang_ext_AVRInterrupt_CXX11_gnu_interrupt;
case 2: return clang_ext_AVRInterrupt_C2x_gnu_interrupt;
case 3: return clang_ext_AVRInterrupt_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_avrinterrupt_spelling_val: %d", Int_val(ocaml));
return clang_ext_AVRInterrupt_GNU_interrupt;
}
value
Val_clang_ext_avrinterrupt_spelling(enum clang_ext_AVRInterrupt_spelling v)
{
switch (v) {
case clang_ext_AVRInterrupt_GNU_interrupt: return Val_int(0);
case clang_ext_AVRInterrupt_CXX11_gnu_interrupt: return Val_int(1);
case clang_ext_AVRInterrupt_C2x_gnu_interrupt: return Val_int(2);
case clang_ext_AVRInterrupt_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_avrinterrupt_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AVRInterrupt_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AVRInterrupt_spelling result = clang_ext_AVRInterrupt_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_avrinterrupt_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AVRSignal_spelling
Clang_ext_avrsignal_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AVRSignal_GNU_signal;
case 1: return clang_ext_AVRSignal_CXX11_gnu_signal;
case 2: return clang_ext_AVRSignal_C2x_gnu_signal;
case 3: return clang_ext_AVRSignal_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_avrsignal_spelling_val: %d", Int_val(ocaml));
return clang_ext_AVRSignal_GNU_signal;
}
value
Val_clang_ext_avrsignal_spelling(enum clang_ext_AVRSignal_spelling v)
{
switch (v) {
case clang_ext_AVRSignal_GNU_signal: return Val_int(0);
case clang_ext_AVRSignal_CXX11_gnu_signal: return Val_int(1);
case clang_ext_AVRSignal_C2x_gnu_signal: return Val_int(2);
case clang_ext_AVRSignal_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_avrsignal_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AVRSignal_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AVRSignal_spelling result = clang_ext_AVRSignal_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_avrsignal_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AbiTag_spelling
Clang_ext_abitag_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AbiTag_GNU_abi_tag;
case 1: return clang_ext_AbiTag_CXX11_gnu_abi_tag;
case 2: return clang_ext_AbiTag_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_abitag_spelling_val: %d", Int_val(ocaml));
return clang_ext_AbiTag_GNU_abi_tag;
}
value
Val_clang_ext_abitag_spelling(enum clang_ext_AbiTag_spelling v)
{
switch (v) {
case clang_ext_AbiTag_GNU_abi_tag: return Val_int(0);
case clang_ext_AbiTag_CXX11_gnu_abi_tag: return Val_int(1);
case clang_ext_AbiTag_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_abitag_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AbiTag_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AbiTag_spelling result = clang_ext_AbiTag_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_abitag_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AcquireCapability_spelling
Clang_ext_acquirecapability_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AcquireCapability_GNU_acquire_capability;
case 1: return clang_ext_AcquireCapability_CXX11_clang_acquire_capability;
case 2: return clang_ext_AcquireCapability_GNU_acquire_shared_capability;
case 3: return clang_ext_AcquireCapability_CXX11_clang_acquire_shared_capability;
case 4: return clang_ext_AcquireCapability_GNU_exclusive_lock_function;
case 5: return clang_ext_AcquireCapability_GNU_shared_lock_function;
case 6: return clang_ext_AcquireCapability_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_acquirecapability_spelling_val: %d", Int_val(ocaml));
return clang_ext_AcquireCapability_GNU_acquire_capability;
}
value
Val_clang_ext_acquirecapability_spelling(enum clang_ext_AcquireCapability_spelling v)
{
switch (v) {
case clang_ext_AcquireCapability_GNU_acquire_capability: return Val_int(0);
case clang_ext_AcquireCapability_CXX11_clang_acquire_capability: return Val_int(1);
case clang_ext_AcquireCapability_GNU_acquire_shared_capability: return Val_int(2);
case clang_ext_AcquireCapability_CXX11_clang_acquire_shared_capability: return Val_int(3);
case clang_ext_AcquireCapability_GNU_exclusive_lock_function: return Val_int(4);
case clang_ext_AcquireCapability_GNU_shared_lock_function: return Val_int(5);
case clang_ext_AcquireCapability_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_acquirecapability_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AcquireCapability_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AcquireCapability_spelling result = clang_ext_AcquireCapability_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_acquirecapability_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AcquireHandle_spelling
Clang_ext_acquirehandle_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AcquireHandle_GNU_acquire_handle;
case 1: return clang_ext_AcquireHandle_CXX11_clang_acquire_handle;
case 2: return clang_ext_AcquireHandle_C2x_clang_acquire_handle;
case 3: return clang_ext_AcquireHandle_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_acquirehandle_spelling_val: %d", Int_val(ocaml));
return clang_ext_AcquireHandle_GNU_acquire_handle;
}
value
Val_clang_ext_acquirehandle_spelling(enum clang_ext_AcquireHandle_spelling v)
{
switch (v) {
case clang_ext_AcquireHandle_GNU_acquire_handle: return Val_int(0);
case clang_ext_AcquireHandle_CXX11_clang_acquire_handle: return Val_int(1);
case clang_ext_AcquireHandle_C2x_clang_acquire_handle: return Val_int(2);
case clang_ext_AcquireHandle_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_acquirehandle_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AcquireHandle_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AcquireHandle_spelling result = clang_ext_AcquireHandle_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_acquirehandle_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AddressSpace_spelling
Clang_ext_addressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AddressSpace_GNU_address_space;
case 1: return clang_ext_AddressSpace_CXX11_clang_address_space;
case 2: return clang_ext_AddressSpace_C2x_clang_address_space;
case 3: return clang_ext_AddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_addressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_AddressSpace_GNU_address_space;
}
value
Val_clang_ext_addressspace_spelling(enum clang_ext_AddressSpace_spelling v)
{
switch (v) {
case clang_ext_AddressSpace_GNU_address_space: return Val_int(0);
case clang_ext_AddressSpace_CXX11_clang_address_space: return Val_int(1);
case clang_ext_AddressSpace_C2x_clang_address_space: return Val_int(2);
case clang_ext_AddressSpace_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_addressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AddressSpace_spelling result = clang_ext_AddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_addressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Alias_spelling
Clang_ext_alias_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Alias_GNU_alias;
case 1: return clang_ext_Alias_CXX11_gnu_alias;
case 2: return clang_ext_Alias_C2x_gnu_alias;
case 3: return clang_ext_Alias_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_alias_spelling_val: %d", Int_val(ocaml));
return clang_ext_Alias_GNU_alias;
}
value
Val_clang_ext_alias_spelling(enum clang_ext_Alias_spelling v)
{
switch (v) {
case clang_ext_Alias_GNU_alias: return Val_int(0);
case clang_ext_Alias_CXX11_gnu_alias: return Val_int(1);
case clang_ext_Alias_C2x_gnu_alias: return Val_int(2);
case clang_ext_Alias_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_alias_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Alias_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Alias_spelling result = clang_ext_Alias_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_alias_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Aligned_spelling
Clang_ext_aligned_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Aligned_GNU_aligned;
case 1: return clang_ext_Aligned_CXX11_gnu_aligned;
case 2: return clang_ext_Aligned_C2x_gnu_aligned;
case 3: return clang_ext_Aligned_Declspec_align;
case 4: return clang_ext_Aligned_Keyword_alignas;
case 5: return clang_ext_Aligned_Keyword_Alignas;
case 6: return clang_ext_Aligned_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_aligned_spelling_val: %d", Int_val(ocaml));
return clang_ext_Aligned_GNU_aligned;
}
value
Val_clang_ext_aligned_spelling(enum clang_ext_Aligned_spelling v)
{
switch (v) {
case clang_ext_Aligned_GNU_aligned: return Val_int(0);
case clang_ext_Aligned_CXX11_gnu_aligned: return Val_int(1);
case clang_ext_Aligned_C2x_gnu_aligned: return Val_int(2);
case clang_ext_Aligned_Declspec_align: return Val_int(3);
case clang_ext_Aligned_Keyword_alignas: return Val_int(4);
case clang_ext_Aligned_Keyword_Alignas: return Val_int(5);
case clang_ext_Aligned_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_aligned_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Aligned_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Aligned_spelling result = clang_ext_Aligned_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_aligned_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AllocAlign_spelling
Clang_ext_allocalign_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AllocAlign_GNU_alloc_align;
case 1: return clang_ext_AllocAlign_CXX11_gnu_alloc_align;
case 2: return clang_ext_AllocAlign_C2x_gnu_alloc_align;
case 3: return clang_ext_AllocAlign_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_allocalign_spelling_val: %d", Int_val(ocaml));
return clang_ext_AllocAlign_GNU_alloc_align;
}
value
Val_clang_ext_allocalign_spelling(enum clang_ext_AllocAlign_spelling v)
{
switch (v) {
case clang_ext_AllocAlign_GNU_alloc_align: return Val_int(0);
case clang_ext_AllocAlign_CXX11_gnu_alloc_align: return Val_int(1);
case clang_ext_AllocAlign_C2x_gnu_alloc_align: return Val_int(2);
case clang_ext_AllocAlign_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_allocalign_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AllocAlign_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AllocAlign_spelling result = clang_ext_AllocAlign_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_allocalign_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AllocSize_spelling
Clang_ext_allocsize_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AllocSize_GNU_alloc_size;
case 1: return clang_ext_AllocSize_CXX11_gnu_alloc_size;
case 2: return clang_ext_AllocSize_C2x_gnu_alloc_size;
case 3: return clang_ext_AllocSize_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_allocsize_spelling_val: %d", Int_val(ocaml));
return clang_ext_AllocSize_GNU_alloc_size;
}
value
Val_clang_ext_allocsize_spelling(enum clang_ext_AllocSize_spelling v)
{
switch (v) {
case clang_ext_AllocSize_GNU_alloc_size: return Val_int(0);
case clang_ext_AllocSize_CXX11_gnu_alloc_size: return Val_int(1);
case clang_ext_AllocSize_C2x_gnu_alloc_size: return Val_int(2);
case clang_ext_AllocSize_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_allocsize_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AllocSize_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AllocSize_spelling result = clang_ext_AllocSize_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_allocsize_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AlwaysDestroy_spelling
Clang_ext_alwaysdestroy_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AlwaysDestroy_GNU_always_destroy;
case 1: return clang_ext_AlwaysDestroy_CXX11_clang_always_destroy;
case 2: return clang_ext_AlwaysDestroy_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_alwaysdestroy_spelling_val: %d", Int_val(ocaml));
return clang_ext_AlwaysDestroy_GNU_always_destroy;
}
value
Val_clang_ext_alwaysdestroy_spelling(enum clang_ext_AlwaysDestroy_spelling v)
{
switch (v) {
case clang_ext_AlwaysDestroy_GNU_always_destroy: return Val_int(0);
case clang_ext_AlwaysDestroy_CXX11_clang_always_destroy: return Val_int(1);
case clang_ext_AlwaysDestroy_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_alwaysdestroy_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AlwaysDestroy_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AlwaysDestroy_spelling result = clang_ext_AlwaysDestroy_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_alwaysdestroy_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AlwaysInline_spelling
Clang_ext_alwaysinline_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AlwaysInline_GNU_always_inline;
case 1: return clang_ext_AlwaysInline_CXX11_gnu_always_inline;
case 2: return clang_ext_AlwaysInline_C2x_gnu_always_inline;
case 3: return clang_ext_AlwaysInline_CXX11_clang_always_inline;
case 4: return clang_ext_AlwaysInline_C2x_clang_always_inline;
case 5: return clang_ext_AlwaysInline_Keyword_forceinline;
case 6: return clang_ext_AlwaysInline_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_alwaysinline_spelling_val: %d", Int_val(ocaml));
return clang_ext_AlwaysInline_GNU_always_inline;
}
value
Val_clang_ext_alwaysinline_spelling(enum clang_ext_AlwaysInline_spelling v)
{
switch (v) {
case clang_ext_AlwaysInline_GNU_always_inline: return Val_int(0);
case clang_ext_AlwaysInline_CXX11_gnu_always_inline: return Val_int(1);
case clang_ext_AlwaysInline_C2x_gnu_always_inline: return Val_int(2);
case clang_ext_AlwaysInline_CXX11_clang_always_inline: return Val_int(3);
case clang_ext_AlwaysInline_C2x_clang_always_inline: return Val_int(4);
case clang_ext_AlwaysInline_Keyword_forceinline: return Val_int(5);
case clang_ext_AlwaysInline_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_alwaysinline_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AlwaysInline_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AlwaysInline_spelling result = clang_ext_AlwaysInline_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_alwaysinline_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Annotate_spelling
Clang_ext_annotate_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Annotate_GNU_annotate;
case 1: return clang_ext_Annotate_CXX11_clang_annotate;
case 2: return clang_ext_Annotate_C2x_clang_annotate;
case 3: return clang_ext_Annotate_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_annotate_spelling_val: %d", Int_val(ocaml));
return clang_ext_Annotate_GNU_annotate;
}
value
Val_clang_ext_annotate_spelling(enum clang_ext_Annotate_spelling v)
{
switch (v) {
case clang_ext_Annotate_GNU_annotate: return Val_int(0);
case clang_ext_Annotate_CXX11_clang_annotate: return Val_int(1);
case clang_ext_Annotate_C2x_clang_annotate: return Val_int(2);
case clang_ext_Annotate_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_annotate_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Annotate_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Annotate_spelling result = clang_ext_Annotate_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_annotate_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AnnotateType_spelling
Clang_ext_annotatetype_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AnnotateType_CXX11_clang_annotate_type;
case 1: return clang_ext_AnnotateType_C2x_clang_annotate_type;
case 2: return clang_ext_AnnotateType_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_annotatetype_spelling_val: %d", Int_val(ocaml));
return clang_ext_AnnotateType_CXX11_clang_annotate_type;
}
value
Val_clang_ext_annotatetype_spelling(enum clang_ext_AnnotateType_spelling v)
{
switch (v) {
case clang_ext_AnnotateType_CXX11_clang_annotate_type: return Val_int(0);
case clang_ext_AnnotateType_C2x_clang_annotate_type: return Val_int(1);
case clang_ext_AnnotateType_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_annotatetype_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AnnotateType_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AnnotateType_spelling result = clang_ext_AnnotateType_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_annotatetype_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AnyX86Interrupt_spelling
Clang_ext_anyx86interrupt_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AnyX86Interrupt_GNU_interrupt;
case 1: return clang_ext_AnyX86Interrupt_CXX11_gnu_interrupt;
case 2: return clang_ext_AnyX86Interrupt_C2x_gnu_interrupt;
case 3: return clang_ext_AnyX86Interrupt_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_anyx86interrupt_spelling_val: %d", Int_val(ocaml));
return clang_ext_AnyX86Interrupt_GNU_interrupt;
}
value
Val_clang_ext_anyx86interrupt_spelling(enum clang_ext_AnyX86Interrupt_spelling v)
{
switch (v) {
case clang_ext_AnyX86Interrupt_GNU_interrupt: return Val_int(0);
case clang_ext_AnyX86Interrupt_CXX11_gnu_interrupt: return Val_int(1);
case clang_ext_AnyX86Interrupt_C2x_gnu_interrupt: return Val_int(2);
case clang_ext_AnyX86Interrupt_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_anyx86interrupt_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AnyX86Interrupt_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AnyX86Interrupt_spelling result = clang_ext_AnyX86Interrupt_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_anyx86interrupt_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AnyX86NoCallerSavedRegisters_spelling
Clang_ext_anyx86nocallersavedregisters_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AnyX86NoCallerSavedRegisters_GNU_no_caller_saved_registers;
case 1: return clang_ext_AnyX86NoCallerSavedRegisters_CXX11_gnu_no_caller_saved_registers;
case 2: return clang_ext_AnyX86NoCallerSavedRegisters_C2x_gnu_no_caller_saved_registers;
case 3: return clang_ext_AnyX86NoCallerSavedRegisters_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_anyx86nocallersavedregisters_spelling_val: %d", Int_val(ocaml));
return clang_ext_AnyX86NoCallerSavedRegisters_GNU_no_caller_saved_registers;
}
value
Val_clang_ext_anyx86nocallersavedregisters_spelling(enum clang_ext_AnyX86NoCallerSavedRegisters_spelling v)
{
switch (v) {
case clang_ext_AnyX86NoCallerSavedRegisters_GNU_no_caller_saved_registers: return Val_int(0);
case clang_ext_AnyX86NoCallerSavedRegisters_CXX11_gnu_no_caller_saved_registers: return Val_int(1);
case clang_ext_AnyX86NoCallerSavedRegisters_C2x_gnu_no_caller_saved_registers: return Val_int(2);
case clang_ext_AnyX86NoCallerSavedRegisters_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_anyx86nocallersavedregisters_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AnyX86NoCallerSavedRegisters_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AnyX86NoCallerSavedRegisters_spelling result = clang_ext_AnyX86NoCallerSavedRegisters_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_anyx86nocallersavedregisters_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AnyX86NoCfCheck_spelling
Clang_ext_anyx86nocfcheck_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AnyX86NoCfCheck_GNU_nocf_check;
case 1: return clang_ext_AnyX86NoCfCheck_CXX11_gnu_nocf_check;
case 2: return clang_ext_AnyX86NoCfCheck_C2x_gnu_nocf_check;
case 3: return clang_ext_AnyX86NoCfCheck_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_anyx86nocfcheck_spelling_val: %d", Int_val(ocaml));
return clang_ext_AnyX86NoCfCheck_GNU_nocf_check;
}
value
Val_clang_ext_anyx86nocfcheck_spelling(enum clang_ext_AnyX86NoCfCheck_spelling v)
{
switch (v) {
case clang_ext_AnyX86NoCfCheck_GNU_nocf_check: return Val_int(0);
case clang_ext_AnyX86NoCfCheck_CXX11_gnu_nocf_check: return Val_int(1);
case clang_ext_AnyX86NoCfCheck_C2x_gnu_nocf_check: return Val_int(2);
case clang_ext_AnyX86NoCfCheck_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_anyx86nocfcheck_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AnyX86NoCfCheck_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AnyX86NoCfCheck_spelling result = clang_ext_AnyX86NoCfCheck_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_anyx86nocfcheck_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ArcWeakrefUnavailable_spelling
Clang_ext_arcweakrefunavailable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ArcWeakrefUnavailable_GNU_objc_arc_weak_reference_unavailable;
case 1: return clang_ext_ArcWeakrefUnavailable_CXX11_clang_objc_arc_weak_reference_unavailable;
case 2: return clang_ext_ArcWeakrefUnavailable_C2x_clang_objc_arc_weak_reference_unavailable;
case 3: return clang_ext_ArcWeakrefUnavailable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_arcweakrefunavailable_spelling_val: %d", Int_val(ocaml));
return clang_ext_ArcWeakrefUnavailable_GNU_objc_arc_weak_reference_unavailable;
}
value
Val_clang_ext_arcweakrefunavailable_spelling(enum clang_ext_ArcWeakrefUnavailable_spelling v)
{
switch (v) {
case clang_ext_ArcWeakrefUnavailable_GNU_objc_arc_weak_reference_unavailable: return Val_int(0);
case clang_ext_ArcWeakrefUnavailable_CXX11_clang_objc_arc_weak_reference_unavailable: return Val_int(1);
case clang_ext_ArcWeakrefUnavailable_C2x_clang_objc_arc_weak_reference_unavailable: return Val_int(2);
case clang_ext_ArcWeakrefUnavailable_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_arcweakrefunavailable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ArcWeakrefUnavailable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ArcWeakrefUnavailable_spelling result = clang_ext_ArcWeakrefUnavailable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_arcweakrefunavailable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ArgumentWithTypeTag_spelling
Clang_ext_argumentwithtypetag_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ArgumentWithTypeTag_GNU_argument_with_type_tag;
case 1: return clang_ext_ArgumentWithTypeTag_CXX11_clang_argument_with_type_tag;
case 2: return clang_ext_ArgumentWithTypeTag_C2x_clang_argument_with_type_tag;
case 3: return clang_ext_ArgumentWithTypeTag_GNU_pointer_with_type_tag;
case 4: return clang_ext_ArgumentWithTypeTag_CXX11_clang_pointer_with_type_tag;
case 5: return clang_ext_ArgumentWithTypeTag_C2x_clang_pointer_with_type_tag;
case 6: return clang_ext_ArgumentWithTypeTag_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_argumentwithtypetag_spelling_val: %d", Int_val(ocaml));
return clang_ext_ArgumentWithTypeTag_GNU_argument_with_type_tag;
}
value
Val_clang_ext_argumentwithtypetag_spelling(enum clang_ext_ArgumentWithTypeTag_spelling v)
{
switch (v) {
case clang_ext_ArgumentWithTypeTag_GNU_argument_with_type_tag: return Val_int(0);
case clang_ext_ArgumentWithTypeTag_CXX11_clang_argument_with_type_tag: return Val_int(1);
case clang_ext_ArgumentWithTypeTag_C2x_clang_argument_with_type_tag: return Val_int(2);
case clang_ext_ArgumentWithTypeTag_GNU_pointer_with_type_tag: return Val_int(3);
case clang_ext_ArgumentWithTypeTag_CXX11_clang_pointer_with_type_tag: return Val_int(4);
case clang_ext_ArgumentWithTypeTag_C2x_clang_pointer_with_type_tag: return Val_int(5);
case clang_ext_ArgumentWithTypeTag_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_argumentwithtypetag_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ArgumentWithTypeTag_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ArgumentWithTypeTag_spelling result = clang_ext_ArgumentWithTypeTag_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_argumentwithtypetag_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ArmBuiltinAlias_spelling
Clang_ext_armbuiltinalias_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ArmBuiltinAlias_GNU_clang_arm_builtin_alias;
case 1: return clang_ext_ArmBuiltinAlias_CXX11_clang_clang_arm_builtin_alias;
case 2: return clang_ext_ArmBuiltinAlias_C2x_clang_clang_arm_builtin_alias;
case 3: return clang_ext_ArmBuiltinAlias_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_armbuiltinalias_spelling_val: %d", Int_val(ocaml));
return clang_ext_ArmBuiltinAlias_GNU_clang_arm_builtin_alias;
}
value
Val_clang_ext_armbuiltinalias_spelling(enum clang_ext_ArmBuiltinAlias_spelling v)
{
switch (v) {
case clang_ext_ArmBuiltinAlias_GNU_clang_arm_builtin_alias: return Val_int(0);
case clang_ext_ArmBuiltinAlias_CXX11_clang_clang_arm_builtin_alias: return Val_int(1);
case clang_ext_ArmBuiltinAlias_C2x_clang_clang_arm_builtin_alias: return Val_int(2);
case clang_ext_ArmBuiltinAlias_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_armbuiltinalias_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ArmBuiltinAlias_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ArmBuiltinAlias_spelling result = clang_ext_ArmBuiltinAlias_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_armbuiltinalias_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ArmMveStrictPolymorphism_spelling
Clang_ext_armmvestrictpolymorphism_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ArmMveStrictPolymorphism_GNU_clang_arm_mve_strict_polymorphism;
case 1: return clang_ext_ArmMveStrictPolymorphism_CXX11_clang_clang_arm_mve_strict_polymorphism;
case 2: return clang_ext_ArmMveStrictPolymorphism_C2x_clang_clang_arm_mve_strict_polymorphism;
case 3: return clang_ext_ArmMveStrictPolymorphism_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_armmvestrictpolymorphism_spelling_val: %d", Int_val(ocaml));
return clang_ext_ArmMveStrictPolymorphism_GNU_clang_arm_mve_strict_polymorphism;
}
value
Val_clang_ext_armmvestrictpolymorphism_spelling(enum clang_ext_ArmMveStrictPolymorphism_spelling v)
{
switch (v) {
case clang_ext_ArmMveStrictPolymorphism_GNU_clang_arm_mve_strict_polymorphism: return Val_int(0);
case clang_ext_ArmMveStrictPolymorphism_CXX11_clang_clang_arm_mve_strict_polymorphism: return Val_int(1);
case clang_ext_ArmMveStrictPolymorphism_C2x_clang_clang_arm_mve_strict_polymorphism: return Val_int(2);
case clang_ext_ArmMveStrictPolymorphism_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_armmvestrictpolymorphism_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ArmMveStrictPolymorphism_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ArmMveStrictPolymorphism_spelling result = clang_ext_ArmMveStrictPolymorphism_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_armmvestrictpolymorphism_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Artificial_spelling
Clang_ext_artificial_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Artificial_GNU_artificial;
case 1: return clang_ext_Artificial_CXX11_gnu_artificial;
case 2: return clang_ext_Artificial_C2x_gnu_artificial;
case 3: return clang_ext_Artificial_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_artificial_spelling_val: %d", Int_val(ocaml));
return clang_ext_Artificial_GNU_artificial;
}
value
Val_clang_ext_artificial_spelling(enum clang_ext_Artificial_spelling v)
{
switch (v) {
case clang_ext_Artificial_GNU_artificial: return Val_int(0);
case clang_ext_Artificial_CXX11_gnu_artificial: return Val_int(1);
case clang_ext_Artificial_C2x_gnu_artificial: return Val_int(2);
case clang_ext_Artificial_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_artificial_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Artificial_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Artificial_spelling result = clang_ext_Artificial_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_artificial_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AsmLabel_spelling
Clang_ext_asmlabel_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AsmLabel_Keyword_asm;
case 1: return clang_ext_AsmLabel_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_asmlabel_spelling_val: %d", Int_val(ocaml));
return clang_ext_AsmLabel_Keyword_asm;
}
value
Val_clang_ext_asmlabel_spelling(enum clang_ext_AsmLabel_spelling v)
{
switch (v) {
case clang_ext_AsmLabel_Keyword_asm: return Val_int(0);
case clang_ext_AsmLabel_SpellingNotCalculated: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_asmlabel_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AsmLabel_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AsmLabel_spelling result = clang_ext_AsmLabel_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_asmlabel_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AssertCapability_spelling
Clang_ext_assertcapability_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AssertCapability_GNU_assert_capability;
case 1: return clang_ext_AssertCapability_CXX11_clang_assert_capability;
case 2: return clang_ext_AssertCapability_GNU_assert_shared_capability;
case 3: return clang_ext_AssertCapability_CXX11_clang_assert_shared_capability;
case 4: return clang_ext_AssertCapability_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_assertcapability_spelling_val: %d", Int_val(ocaml));
return clang_ext_AssertCapability_GNU_assert_capability;
}
value
Val_clang_ext_assertcapability_spelling(enum clang_ext_AssertCapability_spelling v)
{
switch (v) {
case clang_ext_AssertCapability_GNU_assert_capability: return Val_int(0);
case clang_ext_AssertCapability_CXX11_clang_assert_capability: return Val_int(1);
case clang_ext_AssertCapability_GNU_assert_shared_capability: return Val_int(2);
case clang_ext_AssertCapability_CXX11_clang_assert_shared_capability: return Val_int(3);
case clang_ext_AssertCapability_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_assertcapability_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AssertCapability_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AssertCapability_spelling result = clang_ext_AssertCapability_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_assertcapability_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_AssumeAligned_spelling
Clang_ext_assumealigned_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_AssumeAligned_GNU_assume_aligned;
case 1: return clang_ext_AssumeAligned_CXX11_gnu_assume_aligned;
case 2: return clang_ext_AssumeAligned_C2x_gnu_assume_aligned;
case 3: return clang_ext_AssumeAligned_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_assumealigned_spelling_val: %d", Int_val(ocaml));
return clang_ext_AssumeAligned_GNU_assume_aligned;
}
value
Val_clang_ext_assumealigned_spelling(enum clang_ext_AssumeAligned_spelling v)
{
switch (v) {
case clang_ext_AssumeAligned_GNU_assume_aligned: return Val_int(0);
case clang_ext_AssumeAligned_CXX11_gnu_assume_aligned: return Val_int(1);
case clang_ext_AssumeAligned_C2x_gnu_assume_aligned: return Val_int(2);
case clang_ext_AssumeAligned_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_assumealigned_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_AssumeAligned_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_AssumeAligned_spelling result = clang_ext_AssumeAligned_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_assumealigned_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Assumption_spelling
Clang_ext_assumption_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Assumption_GNU_assume;
case 1: return clang_ext_Assumption_CXX11_clang_assume;
case 2: return clang_ext_Assumption_C2x_clang_assume;
case 3: return clang_ext_Assumption_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_assumption_spelling_val: %d", Int_val(ocaml));
return clang_ext_Assumption_GNU_assume;
}
value
Val_clang_ext_assumption_spelling(enum clang_ext_Assumption_spelling v)
{
switch (v) {
case clang_ext_Assumption_GNU_assume: return Val_int(0);
case clang_ext_Assumption_CXX11_clang_assume: return Val_int(1);
case clang_ext_Assumption_C2x_clang_assume: return Val_int(2);
case clang_ext_Assumption_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_assumption_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Assumption_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Assumption_spelling result = clang_ext_Assumption_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_assumption_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Availability_spelling
Clang_ext_availability_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Availability_GNU_availability;
case 1: return clang_ext_Availability_CXX11_clang_availability;
case 2: return clang_ext_Availability_C2x_clang_availability;
case 3: return clang_ext_Availability_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_availability_spelling_val: %d", Int_val(ocaml));
return clang_ext_Availability_GNU_availability;
}
value
Val_clang_ext_availability_spelling(enum clang_ext_Availability_spelling v)
{
switch (v) {
case clang_ext_Availability_GNU_availability: return Val_int(0);
case clang_ext_Availability_CXX11_clang_availability: return Val_int(1);
case clang_ext_Availability_C2x_clang_availability: return Val_int(2);
case clang_ext_Availability_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_availability_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Availability_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Availability_spelling result = clang_ext_Availability_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_availability_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_BPFPreserveAccessIndex_spelling
Clang_ext_bpfpreserveaccessindex_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_BPFPreserveAccessIndex_GNU_preserve_access_index;
case 1: return clang_ext_BPFPreserveAccessIndex_CXX11_clang_preserve_access_index;
case 2: return clang_ext_BPFPreserveAccessIndex_C2x_clang_preserve_access_index;
case 3: return clang_ext_BPFPreserveAccessIndex_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_bpfpreserveaccessindex_spelling_val: %d", Int_val(ocaml));
return clang_ext_BPFPreserveAccessIndex_GNU_preserve_access_index;
}
value
Val_clang_ext_bpfpreserveaccessindex_spelling(enum clang_ext_BPFPreserveAccessIndex_spelling v)
{
switch (v) {
case clang_ext_BPFPreserveAccessIndex_GNU_preserve_access_index: return Val_int(0);
case clang_ext_BPFPreserveAccessIndex_CXX11_clang_preserve_access_index: return Val_int(1);
case clang_ext_BPFPreserveAccessIndex_C2x_clang_preserve_access_index: return Val_int(2);
case clang_ext_BPFPreserveAccessIndex_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_bpfpreserveaccessindex_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_BPFPreserveAccessIndex_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_BPFPreserveAccessIndex_spelling result = clang_ext_BPFPreserveAccessIndex_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_bpfpreserveaccessindex_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_BTFDeclTag_spelling
Clang_ext_btfdecltag_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_BTFDeclTag_GNU_btf_decl_tag;
case 1: return clang_ext_BTFDeclTag_CXX11_clang_btf_decl_tag;
case 2: return clang_ext_BTFDeclTag_C2x_clang_btf_decl_tag;
case 3: return clang_ext_BTFDeclTag_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_btfdecltag_spelling_val: %d", Int_val(ocaml));
return clang_ext_BTFDeclTag_GNU_btf_decl_tag;
}
value
Val_clang_ext_btfdecltag_spelling(enum clang_ext_BTFDeclTag_spelling v)
{
switch (v) {
case clang_ext_BTFDeclTag_GNU_btf_decl_tag: return Val_int(0);
case clang_ext_BTFDeclTag_CXX11_clang_btf_decl_tag: return Val_int(1);
case clang_ext_BTFDeclTag_C2x_clang_btf_decl_tag: return Val_int(2);
case clang_ext_BTFDeclTag_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_btfdecltag_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_BTFDeclTag_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_BTFDeclTag_spelling result = clang_ext_BTFDeclTag_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_btfdecltag_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_BTFTypeTag_spelling
Clang_ext_btftypetag_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_BTFTypeTag_GNU_btf_type_tag;
case 1: return clang_ext_BTFTypeTag_CXX11_clang_btf_type_tag;
case 2: return clang_ext_BTFTypeTag_C2x_clang_btf_type_tag;
case 3: return clang_ext_BTFTypeTag_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_btftypetag_spelling_val: %d", Int_val(ocaml));
return clang_ext_BTFTypeTag_GNU_btf_type_tag;
}
value
Val_clang_ext_btftypetag_spelling(enum clang_ext_BTFTypeTag_spelling v)
{
switch (v) {
case clang_ext_BTFTypeTag_GNU_btf_type_tag: return Val_int(0);
case clang_ext_BTFTypeTag_CXX11_clang_btf_type_tag: return Val_int(1);
case clang_ext_BTFTypeTag_C2x_clang_btf_type_tag: return Val_int(2);
case clang_ext_BTFTypeTag_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_btftypetag_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_BTFTypeTag_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_BTFTypeTag_spelling result = clang_ext_BTFTypeTag_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_btftypetag_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Blocks_spelling
Clang_ext_blocks_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Blocks_GNU_blocks;
case 1: return clang_ext_Blocks_CXX11_clang_blocks;
case 2: return clang_ext_Blocks_C2x_clang_blocks;
case 3: return clang_ext_Blocks_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_blocks_spelling_val: %d", Int_val(ocaml));
return clang_ext_Blocks_GNU_blocks;
}
value
Val_clang_ext_blocks_spelling(enum clang_ext_Blocks_spelling v)
{
switch (v) {
case clang_ext_Blocks_GNU_blocks: return Val_int(0);
case clang_ext_Blocks_CXX11_clang_blocks: return Val_int(1);
case clang_ext_Blocks_C2x_clang_blocks: return Val_int(2);
case clang_ext_Blocks_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_blocks_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Blocks_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Blocks_spelling result = clang_ext_Blocks_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_blocks_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_BuiltinAlias_spelling
Clang_ext_builtinalias_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_BuiltinAlias_CXX11_clang_builtin_alias;
case 1: return clang_ext_BuiltinAlias_C2x_clang_builtin_alias;
case 2: return clang_ext_BuiltinAlias_GNU_clang_builtin_alias;
case 3: return clang_ext_BuiltinAlias_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_builtinalias_spelling_val: %d", Int_val(ocaml));
return clang_ext_BuiltinAlias_CXX11_clang_builtin_alias;
}
value
Val_clang_ext_builtinalias_spelling(enum clang_ext_BuiltinAlias_spelling v)
{
switch (v) {
case clang_ext_BuiltinAlias_CXX11_clang_builtin_alias: return Val_int(0);
case clang_ext_BuiltinAlias_C2x_clang_builtin_alias: return Val_int(1);
case clang_ext_BuiltinAlias_GNU_clang_builtin_alias: return Val_int(2);
case clang_ext_BuiltinAlias_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_builtinalias_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_BuiltinAlias_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_BuiltinAlias_spelling result = clang_ext_BuiltinAlias_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_builtinalias_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CDecl_spelling
Clang_ext_cdecl_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CDecl_GNU_cdecl;
case 1: return clang_ext_CDecl_CXX11_gnu_cdecl;
case 2: return clang_ext_CDecl_C2x_gnu_cdecl;
case 3: return clang_ext_CDecl_Keyword_cdecl;
case 4: return clang_ext_CDecl_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cdecl_spelling_val: %d", Int_val(ocaml));
return clang_ext_CDecl_GNU_cdecl;
}
value
Val_clang_ext_cdecl_spelling(enum clang_ext_CDecl_spelling v)
{
switch (v) {
case clang_ext_CDecl_GNU_cdecl: return Val_int(0);
case clang_ext_CDecl_CXX11_gnu_cdecl: return Val_int(1);
case clang_ext_CDecl_C2x_gnu_cdecl: return Val_int(2);
case clang_ext_CDecl_Keyword_cdecl: return Val_int(3);
case clang_ext_CDecl_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cdecl_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CDecl_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CDecl_spelling result = clang_ext_CDecl_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cdecl_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CFAuditedTransfer_spelling
Clang_ext_cfauditedtransfer_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CFAuditedTransfer_GNU_cf_audited_transfer;
case 1: return clang_ext_CFAuditedTransfer_CXX11_clang_cf_audited_transfer;
case 2: return clang_ext_CFAuditedTransfer_C2x_clang_cf_audited_transfer;
case 3: return clang_ext_CFAuditedTransfer_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cfauditedtransfer_spelling_val: %d", Int_val(ocaml));
return clang_ext_CFAuditedTransfer_GNU_cf_audited_transfer;
}
value
Val_clang_ext_cfauditedtransfer_spelling(enum clang_ext_CFAuditedTransfer_spelling v)
{
switch (v) {
case clang_ext_CFAuditedTransfer_GNU_cf_audited_transfer: return Val_int(0);
case clang_ext_CFAuditedTransfer_CXX11_clang_cf_audited_transfer: return Val_int(1);
case clang_ext_CFAuditedTransfer_C2x_clang_cf_audited_transfer: return Val_int(2);
case clang_ext_CFAuditedTransfer_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cfauditedtransfer_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CFAuditedTransfer_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CFAuditedTransfer_spelling result = clang_ext_CFAuditedTransfer_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cfauditedtransfer_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CFConsumed_spelling
Clang_ext_cfconsumed_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CFConsumed_GNU_cf_consumed;
case 1: return clang_ext_CFConsumed_CXX11_clang_cf_consumed;
case 2: return clang_ext_CFConsumed_C2x_clang_cf_consumed;
case 3: return clang_ext_CFConsumed_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cfconsumed_spelling_val: %d", Int_val(ocaml));
return clang_ext_CFConsumed_GNU_cf_consumed;
}
value
Val_clang_ext_cfconsumed_spelling(enum clang_ext_CFConsumed_spelling v)
{
switch (v) {
case clang_ext_CFConsumed_GNU_cf_consumed: return Val_int(0);
case clang_ext_CFConsumed_CXX11_clang_cf_consumed: return Val_int(1);
case clang_ext_CFConsumed_C2x_clang_cf_consumed: return Val_int(2);
case clang_ext_CFConsumed_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cfconsumed_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CFConsumed_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CFConsumed_spelling result = clang_ext_CFConsumed_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cfconsumed_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CFICanonicalJumpTable_spelling
Clang_ext_cficanonicaljumptable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CFICanonicalJumpTable_GNU_cfi_canonical_jump_table;
case 1: return clang_ext_CFICanonicalJumpTable_CXX11_clang_cfi_canonical_jump_table;
case 2: return clang_ext_CFICanonicalJumpTable_C2x_clang_cfi_canonical_jump_table;
case 3: return clang_ext_CFICanonicalJumpTable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cficanonicaljumptable_spelling_val: %d", Int_val(ocaml));
return clang_ext_CFICanonicalJumpTable_GNU_cfi_canonical_jump_table;
}
value
Val_clang_ext_cficanonicaljumptable_spelling(enum clang_ext_CFICanonicalJumpTable_spelling v)
{
switch (v) {
case clang_ext_CFICanonicalJumpTable_GNU_cfi_canonical_jump_table: return Val_int(0);
case clang_ext_CFICanonicalJumpTable_CXX11_clang_cfi_canonical_jump_table: return Val_int(1);
case clang_ext_CFICanonicalJumpTable_C2x_clang_cfi_canonical_jump_table: return Val_int(2);
case clang_ext_CFICanonicalJumpTable_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cficanonicaljumptable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CFICanonicalJumpTable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CFICanonicalJumpTable_spelling result = clang_ext_CFICanonicalJumpTable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cficanonicaljumptable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CFReturnsNotRetained_spelling
Clang_ext_cfreturnsnotretained_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CFReturnsNotRetained_GNU_cf_returns_not_retained;
case 1: return clang_ext_CFReturnsNotRetained_CXX11_clang_cf_returns_not_retained;
case 2: return clang_ext_CFReturnsNotRetained_C2x_clang_cf_returns_not_retained;
case 3: return clang_ext_CFReturnsNotRetained_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cfreturnsnotretained_spelling_val: %d", Int_val(ocaml));
return clang_ext_CFReturnsNotRetained_GNU_cf_returns_not_retained;
}
value
Val_clang_ext_cfreturnsnotretained_spelling(enum clang_ext_CFReturnsNotRetained_spelling v)
{
switch (v) {
case clang_ext_CFReturnsNotRetained_GNU_cf_returns_not_retained: return Val_int(0);
case clang_ext_CFReturnsNotRetained_CXX11_clang_cf_returns_not_retained: return Val_int(1);
case clang_ext_CFReturnsNotRetained_C2x_clang_cf_returns_not_retained: return Val_int(2);
case clang_ext_CFReturnsNotRetained_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cfreturnsnotretained_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CFReturnsNotRetained_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CFReturnsNotRetained_spelling result = clang_ext_CFReturnsNotRetained_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cfreturnsnotretained_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CFReturnsRetained_spelling
Clang_ext_cfreturnsretained_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CFReturnsRetained_GNU_cf_returns_retained;
case 1: return clang_ext_CFReturnsRetained_CXX11_clang_cf_returns_retained;
case 2: return clang_ext_CFReturnsRetained_C2x_clang_cf_returns_retained;
case 3: return clang_ext_CFReturnsRetained_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cfreturnsretained_spelling_val: %d", Int_val(ocaml));
return clang_ext_CFReturnsRetained_GNU_cf_returns_retained;
}
value
Val_clang_ext_cfreturnsretained_spelling(enum clang_ext_CFReturnsRetained_spelling v)
{
switch (v) {
case clang_ext_CFReturnsRetained_GNU_cf_returns_retained: return Val_int(0);
case clang_ext_CFReturnsRetained_CXX11_clang_cf_returns_retained: return Val_int(1);
case clang_ext_CFReturnsRetained_C2x_clang_cf_returns_retained: return Val_int(2);
case clang_ext_CFReturnsRetained_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cfreturnsretained_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CFReturnsRetained_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CFReturnsRetained_spelling result = clang_ext_CFReturnsRetained_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cfreturnsretained_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CFUnknownTransfer_spelling
Clang_ext_cfunknowntransfer_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CFUnknownTransfer_GNU_cf_unknown_transfer;
case 1: return clang_ext_CFUnknownTransfer_CXX11_clang_cf_unknown_transfer;
case 2: return clang_ext_CFUnknownTransfer_C2x_clang_cf_unknown_transfer;
case 3: return clang_ext_CFUnknownTransfer_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cfunknowntransfer_spelling_val: %d", Int_val(ocaml));
return clang_ext_CFUnknownTransfer_GNU_cf_unknown_transfer;
}
value
Val_clang_ext_cfunknowntransfer_spelling(enum clang_ext_CFUnknownTransfer_spelling v)
{
switch (v) {
case clang_ext_CFUnknownTransfer_GNU_cf_unknown_transfer: return Val_int(0);
case clang_ext_CFUnknownTransfer_CXX11_clang_cf_unknown_transfer: return Val_int(1);
case clang_ext_CFUnknownTransfer_C2x_clang_cf_unknown_transfer: return Val_int(2);
case clang_ext_CFUnknownTransfer_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cfunknowntransfer_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CFUnknownTransfer_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CFUnknownTransfer_spelling result = clang_ext_CFUnknownTransfer_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cfunknowntransfer_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CPUDispatch_spelling
Clang_ext_cpudispatch_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CPUDispatch_GNU_cpu_dispatch;
case 1: return clang_ext_CPUDispatch_CXX11_clang_cpu_dispatch;
case 2: return clang_ext_CPUDispatch_C2x_clang_cpu_dispatch;
case 3: return clang_ext_CPUDispatch_Declspec_cpu_dispatch;
case 4: return clang_ext_CPUDispatch_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cpudispatch_spelling_val: %d", Int_val(ocaml));
return clang_ext_CPUDispatch_GNU_cpu_dispatch;
}
value
Val_clang_ext_cpudispatch_spelling(enum clang_ext_CPUDispatch_spelling v)
{
switch (v) {
case clang_ext_CPUDispatch_GNU_cpu_dispatch: return Val_int(0);
case clang_ext_CPUDispatch_CXX11_clang_cpu_dispatch: return Val_int(1);
case clang_ext_CPUDispatch_C2x_clang_cpu_dispatch: return Val_int(2);
case clang_ext_CPUDispatch_Declspec_cpu_dispatch: return Val_int(3);
case clang_ext_CPUDispatch_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cpudispatch_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CPUDispatch_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CPUDispatch_spelling result = clang_ext_CPUDispatch_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cpudispatch_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CPUSpecific_spelling
Clang_ext_cpuspecific_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CPUSpecific_GNU_cpu_specific;
case 1: return clang_ext_CPUSpecific_CXX11_clang_cpu_specific;
case 2: return clang_ext_CPUSpecific_C2x_clang_cpu_specific;
case 3: return clang_ext_CPUSpecific_Declspec_cpu_specific;
case 4: return clang_ext_CPUSpecific_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cpuspecific_spelling_val: %d", Int_val(ocaml));
return clang_ext_CPUSpecific_GNU_cpu_specific;
}
value
Val_clang_ext_cpuspecific_spelling(enum clang_ext_CPUSpecific_spelling v)
{
switch (v) {
case clang_ext_CPUSpecific_GNU_cpu_specific: return Val_int(0);
case clang_ext_CPUSpecific_CXX11_clang_cpu_specific: return Val_int(1);
case clang_ext_CPUSpecific_C2x_clang_cpu_specific: return Val_int(2);
case clang_ext_CPUSpecific_Declspec_cpu_specific: return Val_int(3);
case clang_ext_CPUSpecific_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cpuspecific_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CPUSpecific_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CPUSpecific_spelling result = clang_ext_CPUSpecific_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cpuspecific_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDAConstant_spelling
Clang_ext_cudaconstant_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDAConstant_GNU_constant;
case 1: return clang_ext_CUDAConstant_Declspec_constant;
case 2: return clang_ext_CUDAConstant_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudaconstant_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDAConstant_GNU_constant;
}
value
Val_clang_ext_cudaconstant_spelling(enum clang_ext_CUDAConstant_spelling v)
{
switch (v) {
case clang_ext_CUDAConstant_GNU_constant: return Val_int(0);
case clang_ext_CUDAConstant_Declspec_constant: return Val_int(1);
case clang_ext_CUDAConstant_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudaconstant_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDAConstant_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDAConstant_spelling result = clang_ext_CUDAConstant_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudaconstant_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDADevice_spelling
Clang_ext_cudadevice_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDADevice_GNU_device;
case 1: return clang_ext_CUDADevice_Declspec_device;
case 2: return clang_ext_CUDADevice_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudadevice_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDADevice_GNU_device;
}
value
Val_clang_ext_cudadevice_spelling(enum clang_ext_CUDADevice_spelling v)
{
switch (v) {
case clang_ext_CUDADevice_GNU_device: return Val_int(0);
case clang_ext_CUDADevice_Declspec_device: return Val_int(1);
case clang_ext_CUDADevice_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudadevice_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDADevice_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDADevice_spelling result = clang_ext_CUDADevice_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudadevice_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDADeviceBuiltinSurfaceType_spelling
Clang_ext_cudadevicebuiltinsurfacetype_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDADeviceBuiltinSurfaceType_GNU_device_builtin_surface_type;
case 1: return clang_ext_CUDADeviceBuiltinSurfaceType_Declspec_device_builtin_surface_type;
case 2: return clang_ext_CUDADeviceBuiltinSurfaceType_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudadevicebuiltinsurfacetype_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDADeviceBuiltinSurfaceType_GNU_device_builtin_surface_type;
}
value
Val_clang_ext_cudadevicebuiltinsurfacetype_spelling(enum clang_ext_CUDADeviceBuiltinSurfaceType_spelling v)
{
switch (v) {
case clang_ext_CUDADeviceBuiltinSurfaceType_GNU_device_builtin_surface_type: return Val_int(0);
case clang_ext_CUDADeviceBuiltinSurfaceType_Declspec_device_builtin_surface_type: return Val_int(1);
case clang_ext_CUDADeviceBuiltinSurfaceType_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudadevicebuiltinsurfacetype_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDADeviceBuiltinSurfaceType_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDADeviceBuiltinSurfaceType_spelling result = clang_ext_CUDADeviceBuiltinSurfaceType_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudadevicebuiltinsurfacetype_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDADeviceBuiltinTextureType_spelling
Clang_ext_cudadevicebuiltintexturetype_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDADeviceBuiltinTextureType_GNU_device_builtin_texture_type;
case 1: return clang_ext_CUDADeviceBuiltinTextureType_Declspec_device_builtin_texture_type;
case 2: return clang_ext_CUDADeviceBuiltinTextureType_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudadevicebuiltintexturetype_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDADeviceBuiltinTextureType_GNU_device_builtin_texture_type;
}
value
Val_clang_ext_cudadevicebuiltintexturetype_spelling(enum clang_ext_CUDADeviceBuiltinTextureType_spelling v)
{
switch (v) {
case clang_ext_CUDADeviceBuiltinTextureType_GNU_device_builtin_texture_type: return Val_int(0);
case clang_ext_CUDADeviceBuiltinTextureType_Declspec_device_builtin_texture_type: return Val_int(1);
case clang_ext_CUDADeviceBuiltinTextureType_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudadevicebuiltintexturetype_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDADeviceBuiltinTextureType_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDADeviceBuiltinTextureType_spelling result = clang_ext_CUDADeviceBuiltinTextureType_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudadevicebuiltintexturetype_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDAGlobal_spelling
Clang_ext_cudaglobal_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDAGlobal_GNU_global;
case 1: return clang_ext_CUDAGlobal_Declspec_global;
case 2: return clang_ext_CUDAGlobal_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudaglobal_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDAGlobal_GNU_global;
}
value
Val_clang_ext_cudaglobal_spelling(enum clang_ext_CUDAGlobal_spelling v)
{
switch (v) {
case clang_ext_CUDAGlobal_GNU_global: return Val_int(0);
case clang_ext_CUDAGlobal_Declspec_global: return Val_int(1);
case clang_ext_CUDAGlobal_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudaglobal_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDAGlobal_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDAGlobal_spelling result = clang_ext_CUDAGlobal_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudaglobal_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDAHost_spelling
Clang_ext_cudahost_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDAHost_GNU_host;
case 1: return clang_ext_CUDAHost_Declspec_host;
case 2: return clang_ext_CUDAHost_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudahost_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDAHost_GNU_host;
}
value
Val_clang_ext_cudahost_spelling(enum clang_ext_CUDAHost_spelling v)
{
switch (v) {
case clang_ext_CUDAHost_GNU_host: return Val_int(0);
case clang_ext_CUDAHost_Declspec_host: return Val_int(1);
case clang_ext_CUDAHost_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudahost_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDAHost_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDAHost_spelling result = clang_ext_CUDAHost_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudahost_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDALaunchBounds_spelling
Clang_ext_cudalaunchbounds_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDALaunchBounds_GNU_launch_bounds;
case 1: return clang_ext_CUDALaunchBounds_Declspec_launch_bounds;
case 2: return clang_ext_CUDALaunchBounds_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudalaunchbounds_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDALaunchBounds_GNU_launch_bounds;
}
value
Val_clang_ext_cudalaunchbounds_spelling(enum clang_ext_CUDALaunchBounds_spelling v)
{
switch (v) {
case clang_ext_CUDALaunchBounds_GNU_launch_bounds: return Val_int(0);
case clang_ext_CUDALaunchBounds_Declspec_launch_bounds: return Val_int(1);
case clang_ext_CUDALaunchBounds_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudalaunchbounds_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDALaunchBounds_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDALaunchBounds_spelling result = clang_ext_CUDALaunchBounds_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudalaunchbounds_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CUDAShared_spelling
Clang_ext_cudashared_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CUDAShared_GNU_shared;
case 1: return clang_ext_CUDAShared_Declspec_shared;
case 2: return clang_ext_CUDAShared_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cudashared_spelling_val: %d", Int_val(ocaml));
return clang_ext_CUDAShared_GNU_shared;
}
value
Val_clang_ext_cudashared_spelling(enum clang_ext_CUDAShared_spelling v)
{
switch (v) {
case clang_ext_CUDAShared_GNU_shared: return Val_int(0);
case clang_ext_CUDAShared_Declspec_shared: return Val_int(1);
case clang_ext_CUDAShared_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cudashared_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CUDAShared_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CUDAShared_spelling result = clang_ext_CUDAShared_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cudashared_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CXX11NoReturn_spelling
Clang_ext_cxx11noreturn_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CXX11NoReturn_CXX11_noreturn;
case 1: return clang_ext_CXX11NoReturn_C2x_noreturn;
case 2: return clang_ext_CXX11NoReturn_C2x_Noreturn;
case 3: return clang_ext_CXX11NoReturn_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cxx11noreturn_spelling_val: %d", Int_val(ocaml));
return clang_ext_CXX11NoReturn_CXX11_noreturn;
}
value
Val_clang_ext_cxx11noreturn_spelling(enum clang_ext_CXX11NoReturn_spelling v)
{
switch (v) {
case clang_ext_CXX11NoReturn_CXX11_noreturn: return Val_int(0);
case clang_ext_CXX11NoReturn_C2x_noreturn: return Val_int(1);
case clang_ext_CXX11NoReturn_C2x_Noreturn: return Val_int(2);
case clang_ext_CXX11NoReturn_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cxx11noreturn_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CXX11NoReturn_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CXX11NoReturn_spelling result = clang_ext_CXX11NoReturn_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cxx11noreturn_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CallableWhen_spelling
Clang_ext_callablewhen_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CallableWhen_GNU_callable_when;
case 1: return clang_ext_CallableWhen_CXX11_clang_callable_when;
case 2: return clang_ext_CallableWhen_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_callablewhen_spelling_val: %d", Int_val(ocaml));
return clang_ext_CallableWhen_GNU_callable_when;
}
value
Val_clang_ext_callablewhen_spelling(enum clang_ext_CallableWhen_spelling v)
{
switch (v) {
case clang_ext_CallableWhen_GNU_callable_when: return Val_int(0);
case clang_ext_CallableWhen_CXX11_clang_callable_when: return Val_int(1);
case clang_ext_CallableWhen_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_callablewhen_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CallableWhen_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CallableWhen_spelling result = clang_ext_CallableWhen_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_callablewhen_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Callback_spelling
Clang_ext_callback_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Callback_GNU_callback;
case 1: return clang_ext_Callback_CXX11_clang_callback;
case 2: return clang_ext_Callback_C2x_clang_callback;
case 3: return clang_ext_Callback_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_callback_spelling_val: %d", Int_val(ocaml));
return clang_ext_Callback_GNU_callback;
}
value
Val_clang_ext_callback_spelling(enum clang_ext_Callback_spelling v)
{
switch (v) {
case clang_ext_Callback_GNU_callback: return Val_int(0);
case clang_ext_Callback_CXX11_clang_callback: return Val_int(1);
case clang_ext_Callback_C2x_clang_callback: return Val_int(2);
case clang_ext_Callback_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_callback_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Callback_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Callback_spelling result = clang_ext_Callback_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_callback_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CalledOnce_spelling
Clang_ext_calledonce_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CalledOnce_GNU_called_once;
case 1: return clang_ext_CalledOnce_CXX11_clang_called_once;
case 2: return clang_ext_CalledOnce_C2x_clang_called_once;
case 3: return clang_ext_CalledOnce_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_calledonce_spelling_val: %d", Int_val(ocaml));
return clang_ext_CalledOnce_GNU_called_once;
}
value
Val_clang_ext_calledonce_spelling(enum clang_ext_CalledOnce_spelling v)
{
switch (v) {
case clang_ext_CalledOnce_GNU_called_once: return Val_int(0);
case clang_ext_CalledOnce_CXX11_clang_called_once: return Val_int(1);
case clang_ext_CalledOnce_C2x_clang_called_once: return Val_int(2);
case clang_ext_CalledOnce_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_calledonce_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CalledOnce_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CalledOnce_spelling result = clang_ext_CalledOnce_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_calledonce_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Capability_spelling
Clang_ext_capability_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Capability_GNU_capability;
case 1: return clang_ext_Capability_CXX11_clang_capability;
case 2: return clang_ext_Capability_GNU_shared_capability;
case 3: return clang_ext_Capability_CXX11_clang_shared_capability;
case 4: return clang_ext_Capability_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_capability_spelling_val: %d", Int_val(ocaml));
return clang_ext_Capability_GNU_capability;
}
value
Val_clang_ext_capability_spelling(enum clang_ext_Capability_spelling v)
{
switch (v) {
case clang_ext_Capability_GNU_capability: return Val_int(0);
case clang_ext_Capability_CXX11_clang_capability: return Val_int(1);
case clang_ext_Capability_GNU_shared_capability: return Val_int(2);
case clang_ext_Capability_CXX11_clang_shared_capability: return Val_int(3);
case clang_ext_Capability_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_capability_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Capability_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Capability_spelling result = clang_ext_Capability_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_capability_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_CarriesDependency_spelling
Clang_ext_carriesdependency_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CarriesDependency_GNU_carries_dependency;
case 1: return clang_ext_CarriesDependency_CXX11_carries_dependency;
case 2: return clang_ext_CarriesDependency_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_carriesdependency_spelling_val: %d", Int_val(ocaml));
return clang_ext_CarriesDependency_GNU_carries_dependency;
}
value
Val_clang_ext_carriesdependency_spelling(enum clang_ext_CarriesDependency_spelling v)
{
switch (v) {
case clang_ext_CarriesDependency_GNU_carries_dependency: return Val_int(0);
case clang_ext_CarriesDependency_CXX11_carries_dependency: return Val_int(1);
case clang_ext_CarriesDependency_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_carriesdependency_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CarriesDependency_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CarriesDependency_spelling result = clang_ext_CarriesDependency_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_carriesdependency_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Cleanup_spelling
Clang_ext_cleanup_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Cleanup_GNU_cleanup;
case 1: return clang_ext_Cleanup_CXX11_gnu_cleanup;
case 2: return clang_ext_Cleanup_C2x_gnu_cleanup;
case 3: return clang_ext_Cleanup_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cleanup_spelling_val: %d", Int_val(ocaml));
return clang_ext_Cleanup_GNU_cleanup;
}
value
Val_clang_ext_cleanup_spelling(enum clang_ext_Cleanup_spelling v)
{
switch (v) {
case clang_ext_Cleanup_GNU_cleanup: return Val_int(0);
case clang_ext_Cleanup_CXX11_gnu_cleanup: return Val_int(1);
case clang_ext_Cleanup_C2x_gnu_cleanup: return Val_int(2);
case clang_ext_Cleanup_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cleanup_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Cleanup_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Cleanup_spelling result = clang_ext_Cleanup_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cleanup_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Cold_spelling
Clang_ext_cold_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Cold_GNU_cold;
case 1: return clang_ext_Cold_CXX11_gnu_cold;
case 2: return clang_ext_Cold_C2x_gnu_cold;
case 3: return clang_ext_Cold_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_cold_spelling_val: %d", Int_val(ocaml));
return clang_ext_Cold_GNU_cold;
}
value
Val_clang_ext_cold_spelling(enum clang_ext_Cold_spelling v)
{
switch (v) {
case clang_ext_Cold_GNU_cold: return Val_int(0);
case clang_ext_Cold_CXX11_gnu_cold: return Val_int(1);
case clang_ext_Cold_C2x_gnu_cold: return Val_int(2);
case clang_ext_Cold_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cold_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Cold_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Cold_spelling result = clang_ext_Cold_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cold_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Common_spelling
Clang_ext_common_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Common_GNU_common;
case 1: return clang_ext_Common_CXX11_gnu_common;
case 2: return clang_ext_Common_C2x_gnu_common;
case 3: return clang_ext_Common_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_common_spelling_val: %d", Int_val(ocaml));
return clang_ext_Common_GNU_common;
}
value
Val_clang_ext_common_spelling(enum clang_ext_Common_spelling v)
{
switch (v) {
case clang_ext_Common_GNU_common: return Val_int(0);
case clang_ext_Common_CXX11_gnu_common: return Val_int(1);
case clang_ext_Common_C2x_gnu_common: return Val_int(2);
case clang_ext_Common_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_common_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Common_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Common_spelling result = clang_ext_Common_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_common_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Const_spelling
Clang_ext_const_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Const_GNU_const;
case 1: return clang_ext_Const_CXX11_gnu_const;
case 2: return clang_ext_Const_C2x_gnu_const;
case 3: return clang_ext_Const_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_const_spelling_val: %d", Int_val(ocaml));
return clang_ext_Const_GNU_const;
}
value
Val_clang_ext_const_spelling(enum clang_ext_Const_spelling v)
{
switch (v) {
case clang_ext_Const_GNU_const: return Val_int(0);
case clang_ext_Const_CXX11_gnu_const: return Val_int(1);
case clang_ext_Const_C2x_gnu_const: return Val_int(2);
case clang_ext_Const_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_const_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Const_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Const_spelling result = clang_ext_Const_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_const_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ConstInit_spelling
Clang_ext_constinit_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ConstInit_Keyword_constinit;
case 1: return clang_ext_ConstInit_GNU_require_constant_initialization;
case 2: return clang_ext_ConstInit_CXX11_clang_require_constant_initialization;
case 3: return clang_ext_ConstInit_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_constinit_spelling_val: %d", Int_val(ocaml));
return clang_ext_ConstInit_Keyword_constinit;
}
value
Val_clang_ext_constinit_spelling(enum clang_ext_ConstInit_spelling v)
{
switch (v) {
case clang_ext_ConstInit_Keyword_constinit: return Val_int(0);
case clang_ext_ConstInit_GNU_require_constant_initialization: return Val_int(1);
case clang_ext_ConstInit_CXX11_clang_require_constant_initialization: return Val_int(2);
case clang_ext_ConstInit_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_constinit_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ConstInit_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ConstInit_spelling result = clang_ext_ConstInit_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_constinit_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Constructor_spelling
Clang_ext_constructor_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Constructor_GNU_constructor;
case 1: return clang_ext_Constructor_CXX11_gnu_constructor;
case 2: return clang_ext_Constructor_C2x_gnu_constructor;
case 3: return clang_ext_Constructor_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_constructor_spelling_val: %d", Int_val(ocaml));
return clang_ext_Constructor_GNU_constructor;
}
value
Val_clang_ext_constructor_spelling(enum clang_ext_Constructor_spelling v)
{
switch (v) {
case clang_ext_Constructor_GNU_constructor: return Val_int(0);
case clang_ext_Constructor_CXX11_gnu_constructor: return Val_int(1);
case clang_ext_Constructor_C2x_gnu_constructor: return Val_int(2);
case clang_ext_Constructor_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_constructor_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Constructor_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Constructor_spelling result = clang_ext_Constructor_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_constructor_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Consumable_spelling
Clang_ext_consumable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Consumable_GNU_consumable;
case 1: return clang_ext_Consumable_CXX11_clang_consumable;
case 2: return clang_ext_Consumable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_consumable_spelling_val: %d", Int_val(ocaml));
return clang_ext_Consumable_GNU_consumable;
}
value
Val_clang_ext_consumable_spelling(enum clang_ext_Consumable_spelling v)
{
switch (v) {
case clang_ext_Consumable_GNU_consumable: return Val_int(0);
case clang_ext_Consumable_CXX11_clang_consumable: return Val_int(1);
case clang_ext_Consumable_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_consumable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Consumable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Consumable_spelling result = clang_ext_Consumable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_consumable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ConsumableAutoCast_spelling
Clang_ext_consumableautocast_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ConsumableAutoCast_GNU_consumable_auto_cast_state;
case 1: return clang_ext_ConsumableAutoCast_CXX11_clang_consumable_auto_cast_state;
case 2: return clang_ext_ConsumableAutoCast_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_consumableautocast_spelling_val: %d", Int_val(ocaml));
return clang_ext_ConsumableAutoCast_GNU_consumable_auto_cast_state;
}
value
Val_clang_ext_consumableautocast_spelling(enum clang_ext_ConsumableAutoCast_spelling v)
{
switch (v) {
case clang_ext_ConsumableAutoCast_GNU_consumable_auto_cast_state: return Val_int(0);
case clang_ext_ConsumableAutoCast_CXX11_clang_consumable_auto_cast_state: return Val_int(1);
case clang_ext_ConsumableAutoCast_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_consumableautocast_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ConsumableAutoCast_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ConsumableAutoCast_spelling result = clang_ext_ConsumableAutoCast_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_consumableautocast_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ConsumableSetOnRead_spelling
Clang_ext_consumablesetonread_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ConsumableSetOnRead_GNU_consumable_set_state_on_read;
case 1: return clang_ext_ConsumableSetOnRead_CXX11_clang_consumable_set_state_on_read;
case 2: return clang_ext_ConsumableSetOnRead_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_consumablesetonread_spelling_val: %d", Int_val(ocaml));
return clang_ext_ConsumableSetOnRead_GNU_consumable_set_state_on_read;
}
value
Val_clang_ext_consumablesetonread_spelling(enum clang_ext_ConsumableSetOnRead_spelling v)
{
switch (v) {
case clang_ext_ConsumableSetOnRead_GNU_consumable_set_state_on_read: return Val_int(0);
case clang_ext_ConsumableSetOnRead_CXX11_clang_consumable_set_state_on_read: return Val_int(1);
case clang_ext_ConsumableSetOnRead_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_consumablesetonread_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ConsumableSetOnRead_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ConsumableSetOnRead_spelling result = clang_ext_ConsumableSetOnRead_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_consumablesetonread_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Convergent_spelling
Clang_ext_convergent_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Convergent_GNU_convergent;
case 1: return clang_ext_Convergent_CXX11_clang_convergent;
case 2: return clang_ext_Convergent_C2x_clang_convergent;
case 3: return clang_ext_Convergent_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_convergent_spelling_val: %d", Int_val(ocaml));
return clang_ext_Convergent_GNU_convergent;
}
value
Val_clang_ext_convergent_spelling(enum clang_ext_Convergent_spelling v)
{
switch (v) {
case clang_ext_Convergent_GNU_convergent: return Val_int(0);
case clang_ext_Convergent_CXX11_clang_convergent: return Val_int(1);
case clang_ext_Convergent_C2x_clang_convergent: return Val_int(2);
case clang_ext_Convergent_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_convergent_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Convergent_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Convergent_spelling result = clang_ext_Convergent_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_convergent_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_DLLExport_spelling
Clang_ext_dllexport_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_DLLExport_Declspec_dllexport;
case 1: return clang_ext_DLLExport_GNU_dllexport;
case 2: return clang_ext_DLLExport_CXX11_gnu_dllexport;
case 3: return clang_ext_DLLExport_C2x_gnu_dllexport;
case 4: return clang_ext_DLLExport_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_dllexport_spelling_val: %d", Int_val(ocaml));
return clang_ext_DLLExport_Declspec_dllexport;
}
value
Val_clang_ext_dllexport_spelling(enum clang_ext_DLLExport_spelling v)
{
switch (v) {
case clang_ext_DLLExport_Declspec_dllexport: return Val_int(0);
case clang_ext_DLLExport_GNU_dllexport: return Val_int(1);
case clang_ext_DLLExport_CXX11_gnu_dllexport: return Val_int(2);
case clang_ext_DLLExport_C2x_gnu_dllexport: return Val_int(3);
case clang_ext_DLLExport_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_dllexport_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_DLLExport_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_DLLExport_spelling result = clang_ext_DLLExport_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_dllexport_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_DLLImport_spelling
Clang_ext_dllimport_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_DLLImport_Declspec_dllimport;
case 1: return clang_ext_DLLImport_GNU_dllimport;
case 2: return clang_ext_DLLImport_CXX11_gnu_dllimport;
case 3: return clang_ext_DLLImport_C2x_gnu_dllimport;
case 4: return clang_ext_DLLImport_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_dllimport_spelling_val: %d", Int_val(ocaml));
return clang_ext_DLLImport_Declspec_dllimport;
}
value
Val_clang_ext_dllimport_spelling(enum clang_ext_DLLImport_spelling v)
{
switch (v) {
case clang_ext_DLLImport_Declspec_dllimport: return Val_int(0);
case clang_ext_DLLImport_GNU_dllimport: return Val_int(1);
case clang_ext_DLLImport_CXX11_gnu_dllimport: return Val_int(2);
case clang_ext_DLLImport_C2x_gnu_dllimport: return Val_int(3);
case clang_ext_DLLImport_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_dllimport_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_DLLImport_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_DLLImport_spelling result = clang_ext_DLLImport_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_dllimport_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Deprecated_spelling
Clang_ext_deprecated_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Deprecated_GNU_deprecated;
case 1: return clang_ext_Deprecated_CXX11_gnu_deprecated;
case 2: return clang_ext_Deprecated_C2x_gnu_deprecated;
case 3: return clang_ext_Deprecated_Declspec_deprecated;
case 4: return clang_ext_Deprecated_CXX11_deprecated;
case 5: return clang_ext_Deprecated_C2x_deprecated;
case 6: return clang_ext_Deprecated_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_deprecated_spelling_val: %d", Int_val(ocaml));
return clang_ext_Deprecated_GNU_deprecated;
}
value
Val_clang_ext_deprecated_spelling(enum clang_ext_Deprecated_spelling v)
{
switch (v) {
case clang_ext_Deprecated_GNU_deprecated: return Val_int(0);
case clang_ext_Deprecated_CXX11_gnu_deprecated: return Val_int(1);
case clang_ext_Deprecated_C2x_gnu_deprecated: return Val_int(2);
case clang_ext_Deprecated_Declspec_deprecated: return Val_int(3);
case clang_ext_Deprecated_CXX11_deprecated: return Val_int(4);
case clang_ext_Deprecated_C2x_deprecated: return Val_int(5);
case clang_ext_Deprecated_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_deprecated_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Deprecated_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Deprecated_spelling result = clang_ext_Deprecated_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_deprecated_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Destructor_spelling
Clang_ext_destructor_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Destructor_GNU_destructor;
case 1: return clang_ext_Destructor_CXX11_gnu_destructor;
case 2: return clang_ext_Destructor_C2x_gnu_destructor;
case 3: return clang_ext_Destructor_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_destructor_spelling_val: %d", Int_val(ocaml));
return clang_ext_Destructor_GNU_destructor;
}
value
Val_clang_ext_destructor_spelling(enum clang_ext_Destructor_spelling v)
{
switch (v) {
case clang_ext_Destructor_GNU_destructor: return Val_int(0);
case clang_ext_Destructor_CXX11_gnu_destructor: return Val_int(1);
case clang_ext_Destructor_C2x_gnu_destructor: return Val_int(2);
case clang_ext_Destructor_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_destructor_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Destructor_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Destructor_spelling result = clang_ext_Destructor_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_destructor_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_DiagnoseAsBuiltin_spelling
Clang_ext_diagnoseasbuiltin_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_DiagnoseAsBuiltin_GNU_diagnose_as_builtin;
case 1: return clang_ext_DiagnoseAsBuiltin_CXX11_clang_diagnose_as_builtin;
case 2: return clang_ext_DiagnoseAsBuiltin_C2x_clang_diagnose_as_builtin;
case 3: return clang_ext_DiagnoseAsBuiltin_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_diagnoseasbuiltin_spelling_val: %d", Int_val(ocaml));
return clang_ext_DiagnoseAsBuiltin_GNU_diagnose_as_builtin;
}
value
Val_clang_ext_diagnoseasbuiltin_spelling(enum clang_ext_DiagnoseAsBuiltin_spelling v)
{
switch (v) {
case clang_ext_DiagnoseAsBuiltin_GNU_diagnose_as_builtin: return Val_int(0);
case clang_ext_DiagnoseAsBuiltin_CXX11_clang_diagnose_as_builtin: return Val_int(1);
case clang_ext_DiagnoseAsBuiltin_C2x_clang_diagnose_as_builtin: return Val_int(2);
case clang_ext_DiagnoseAsBuiltin_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_diagnoseasbuiltin_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_DiagnoseAsBuiltin_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_DiagnoseAsBuiltin_spelling result = clang_ext_DiagnoseAsBuiltin_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_diagnoseasbuiltin_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_DisableSanitizerInstrumentation_spelling
Clang_ext_disablesanitizerinstrumentation_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_DisableSanitizerInstrumentation_GNU_disable_sanitizer_instrumentation;
case 1: return clang_ext_DisableSanitizerInstrumentation_CXX11_clang_disable_sanitizer_instrumentation;
case 2: return clang_ext_DisableSanitizerInstrumentation_C2x_clang_disable_sanitizer_instrumentation;
case 3: return clang_ext_DisableSanitizerInstrumentation_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_disablesanitizerinstrumentation_spelling_val: %d", Int_val(ocaml));
return clang_ext_DisableSanitizerInstrumentation_GNU_disable_sanitizer_instrumentation;
}
value
Val_clang_ext_disablesanitizerinstrumentation_spelling(enum clang_ext_DisableSanitizerInstrumentation_spelling v)
{
switch (v) {
case clang_ext_DisableSanitizerInstrumentation_GNU_disable_sanitizer_instrumentation: return Val_int(0);
case clang_ext_DisableSanitizerInstrumentation_CXX11_clang_disable_sanitizer_instrumentation: return Val_int(1);
case clang_ext_DisableSanitizerInstrumentation_C2x_clang_disable_sanitizer_instrumentation: return Val_int(2);
case clang_ext_DisableSanitizerInstrumentation_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_disablesanitizerinstrumentation_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_DisableSanitizerInstrumentation_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_DisableSanitizerInstrumentation_spelling result = clang_ext_DisableSanitizerInstrumentation_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_disablesanitizerinstrumentation_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_DisableTailCalls_spelling
Clang_ext_disabletailcalls_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_DisableTailCalls_GNU_disable_tail_calls;
case 1: return clang_ext_DisableTailCalls_CXX11_clang_disable_tail_calls;
case 2: return clang_ext_DisableTailCalls_C2x_clang_disable_tail_calls;
case 3: return clang_ext_DisableTailCalls_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_disabletailcalls_spelling_val: %d", Int_val(ocaml));
return clang_ext_DisableTailCalls_GNU_disable_tail_calls;
}
value
Val_clang_ext_disabletailcalls_spelling(enum clang_ext_DisableTailCalls_spelling v)
{
switch (v) {
case clang_ext_DisableTailCalls_GNU_disable_tail_calls: return Val_int(0);
case clang_ext_DisableTailCalls_CXX11_clang_disable_tail_calls: return Val_int(1);
case clang_ext_DisableTailCalls_C2x_clang_disable_tail_calls: return Val_int(2);
case clang_ext_DisableTailCalls_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_disabletailcalls_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_DisableTailCalls_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_DisableTailCalls_spelling result = clang_ext_DisableTailCalls_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_disabletailcalls_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_EnforceTCB_spelling
Clang_ext_enforcetcb_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_EnforceTCB_GNU_enforce_tcb;
case 1: return clang_ext_EnforceTCB_CXX11_clang_enforce_tcb;
case 2: return clang_ext_EnforceTCB_C2x_clang_enforce_tcb;
case 3: return clang_ext_EnforceTCB_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_enforcetcb_spelling_val: %d", Int_val(ocaml));
return clang_ext_EnforceTCB_GNU_enforce_tcb;
}
value
Val_clang_ext_enforcetcb_spelling(enum clang_ext_EnforceTCB_spelling v)
{
switch (v) {
case clang_ext_EnforceTCB_GNU_enforce_tcb: return Val_int(0);
case clang_ext_EnforceTCB_CXX11_clang_enforce_tcb: return Val_int(1);
case clang_ext_EnforceTCB_C2x_clang_enforce_tcb: return Val_int(2);
case clang_ext_EnforceTCB_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_enforcetcb_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_EnforceTCB_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_EnforceTCB_spelling result = clang_ext_EnforceTCB_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_enforcetcb_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_EnforceTCBLeaf_spelling
Clang_ext_enforcetcbleaf_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_EnforceTCBLeaf_GNU_enforce_tcb_leaf;
case 1: return clang_ext_EnforceTCBLeaf_CXX11_clang_enforce_tcb_leaf;
case 2: return clang_ext_EnforceTCBLeaf_C2x_clang_enforce_tcb_leaf;
case 3: return clang_ext_EnforceTCBLeaf_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_enforcetcbleaf_spelling_val: %d", Int_val(ocaml));
return clang_ext_EnforceTCBLeaf_GNU_enforce_tcb_leaf;
}
value
Val_clang_ext_enforcetcbleaf_spelling(enum clang_ext_EnforceTCBLeaf_spelling v)
{
switch (v) {
case clang_ext_EnforceTCBLeaf_GNU_enforce_tcb_leaf: return Val_int(0);
case clang_ext_EnforceTCBLeaf_CXX11_clang_enforce_tcb_leaf: return Val_int(1);
case clang_ext_EnforceTCBLeaf_C2x_clang_enforce_tcb_leaf: return Val_int(2);
case clang_ext_EnforceTCBLeaf_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_enforcetcbleaf_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_EnforceTCBLeaf_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_EnforceTCBLeaf_spelling result = clang_ext_EnforceTCBLeaf_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_enforcetcbleaf_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_EnumExtensibility_spelling
Clang_ext_enumextensibility_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_EnumExtensibility_GNU_enum_extensibility;
case 1: return clang_ext_EnumExtensibility_CXX11_clang_enum_extensibility;
case 2: return clang_ext_EnumExtensibility_C2x_clang_enum_extensibility;
case 3: return clang_ext_EnumExtensibility_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_enumextensibility_spelling_val: %d", Int_val(ocaml));
return clang_ext_EnumExtensibility_GNU_enum_extensibility;
}
value
Val_clang_ext_enumextensibility_spelling(enum clang_ext_EnumExtensibility_spelling v)
{
switch (v) {
case clang_ext_EnumExtensibility_GNU_enum_extensibility: return Val_int(0);
case clang_ext_EnumExtensibility_CXX11_clang_enum_extensibility: return Val_int(1);
case clang_ext_EnumExtensibility_C2x_clang_enum_extensibility: return Val_int(2);
case clang_ext_EnumExtensibility_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_enumextensibility_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_EnumExtensibility_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_EnumExtensibility_spelling result = clang_ext_EnumExtensibility_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_enumextensibility_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Error_spelling
Clang_ext_error_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Error_GNU_error;
case 1: return clang_ext_Error_CXX11_gnu_error;
case 2: return clang_ext_Error_C2x_gnu_error;
case 3: return clang_ext_Error_GNU_warning;
case 4: return clang_ext_Error_CXX11_gnu_warning;
case 5: return clang_ext_Error_C2x_gnu_warning;
case 6: return clang_ext_Error_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_error_spelling_val: %d", Int_val(ocaml));
return clang_ext_Error_GNU_error;
}
value
Val_clang_ext_error_spelling(enum clang_ext_Error_spelling v)
{
switch (v) {
case clang_ext_Error_GNU_error: return Val_int(0);
case clang_ext_Error_CXX11_gnu_error: return Val_int(1);
case clang_ext_Error_C2x_gnu_error: return Val_int(2);
case clang_ext_Error_GNU_warning: return Val_int(3);
case clang_ext_Error_CXX11_gnu_warning: return Val_int(4);
case clang_ext_Error_C2x_gnu_warning: return Val_int(5);
case clang_ext_Error_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_error_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Error_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Error_spelling result = clang_ext_Error_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_error_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ExcludeFromExplicitInstantiation_spelling
Clang_ext_excludefromexplicitinstantiation_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ExcludeFromExplicitInstantiation_GNU_exclude_from_explicit_instantiation;
case 1: return clang_ext_ExcludeFromExplicitInstantiation_CXX11_clang_exclude_from_explicit_instantiation;
case 2: return clang_ext_ExcludeFromExplicitInstantiation_C2x_clang_exclude_from_explicit_instantiation;
case 3: return clang_ext_ExcludeFromExplicitInstantiation_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_excludefromexplicitinstantiation_spelling_val: %d", Int_val(ocaml));
return clang_ext_ExcludeFromExplicitInstantiation_GNU_exclude_from_explicit_instantiation;
}
value
Val_clang_ext_excludefromexplicitinstantiation_spelling(enum clang_ext_ExcludeFromExplicitInstantiation_spelling v)
{
switch (v) {
case clang_ext_ExcludeFromExplicitInstantiation_GNU_exclude_from_explicit_instantiation: return Val_int(0);
case clang_ext_ExcludeFromExplicitInstantiation_CXX11_clang_exclude_from_explicit_instantiation: return Val_int(1);
case clang_ext_ExcludeFromExplicitInstantiation_C2x_clang_exclude_from_explicit_instantiation: return Val_int(2);
case clang_ext_ExcludeFromExplicitInstantiation_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_excludefromexplicitinstantiation_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ExcludeFromExplicitInstantiation_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ExcludeFromExplicitInstantiation_spelling result = clang_ext_ExcludeFromExplicitInstantiation_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_excludefromexplicitinstantiation_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ExternalSourceSymbol_spelling
Clang_ext_externalsourcesymbol_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ExternalSourceSymbol_GNU_external_source_symbol;
case 1: return clang_ext_ExternalSourceSymbol_CXX11_clang_external_source_symbol;
case 2: return clang_ext_ExternalSourceSymbol_C2x_clang_external_source_symbol;
case 3: return clang_ext_ExternalSourceSymbol_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_externalsourcesymbol_spelling_val: %d", Int_val(ocaml));
return clang_ext_ExternalSourceSymbol_GNU_external_source_symbol;
}
value
Val_clang_ext_externalsourcesymbol_spelling(enum clang_ext_ExternalSourceSymbol_spelling v)
{
switch (v) {
case clang_ext_ExternalSourceSymbol_GNU_external_source_symbol: return Val_int(0);
case clang_ext_ExternalSourceSymbol_CXX11_clang_external_source_symbol: return Val_int(1);
case clang_ext_ExternalSourceSymbol_C2x_clang_external_source_symbol: return Val_int(2);
case clang_ext_ExternalSourceSymbol_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_externalsourcesymbol_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ExternalSourceSymbol_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ExternalSourceSymbol_spelling result = clang_ext_ExternalSourceSymbol_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_externalsourcesymbol_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_FallThrough_spelling
Clang_ext_fallthrough_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_FallThrough_CXX11_fallthrough;
case 1: return clang_ext_FallThrough_C2x_fallthrough;
case 2: return clang_ext_FallThrough_CXX11_clang_fallthrough;
case 3: return clang_ext_FallThrough_GNU_fallthrough;
case 4: return clang_ext_FallThrough_CXX11_gnu_fallthrough;
case 5: return clang_ext_FallThrough_C2x_gnu_fallthrough;
case 6: return clang_ext_FallThrough_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_fallthrough_spelling_val: %d", Int_val(ocaml));
return clang_ext_FallThrough_CXX11_fallthrough;
}
value
Val_clang_ext_fallthrough_spelling(enum clang_ext_FallThrough_spelling v)
{
switch (v) {
case clang_ext_FallThrough_CXX11_fallthrough: return Val_int(0);
case clang_ext_FallThrough_C2x_fallthrough: return Val_int(1);
case clang_ext_FallThrough_CXX11_clang_fallthrough: return Val_int(2);
case clang_ext_FallThrough_GNU_fallthrough: return Val_int(3);
case clang_ext_FallThrough_CXX11_gnu_fallthrough: return Val_int(4);
case clang_ext_FallThrough_C2x_gnu_fallthrough: return Val_int(5);
case clang_ext_FallThrough_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_fallthrough_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_FallThrough_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_FallThrough_spelling result = clang_ext_FallThrough_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_fallthrough_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_FastCall_spelling
Clang_ext_fastcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_FastCall_GNU_fastcall;
case 1: return clang_ext_FastCall_CXX11_gnu_fastcall;
case 2: return clang_ext_FastCall_C2x_gnu_fastcall;
case 3: return clang_ext_FastCall_Keyword_fastcall;
case 4: return clang_ext_FastCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_fastcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_FastCall_GNU_fastcall;
}
value
Val_clang_ext_fastcall_spelling(enum clang_ext_FastCall_spelling v)
{
switch (v) {
case clang_ext_FastCall_GNU_fastcall: return Val_int(0);
case clang_ext_FastCall_CXX11_gnu_fastcall: return Val_int(1);
case clang_ext_FastCall_C2x_gnu_fastcall: return Val_int(2);
case clang_ext_FastCall_Keyword_fastcall: return Val_int(3);
case clang_ext_FastCall_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_fastcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_FastCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_FastCall_spelling result = clang_ext_FastCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_fastcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Final_spelling
Clang_ext_final_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Final_Keyword_final;
case 1: return clang_ext_Final_Keyword_sealed;
case 2: return clang_ext_Final_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_final_spelling_val: %d", Int_val(ocaml));
return clang_ext_Final_Keyword_final;
}
value
Val_clang_ext_final_spelling(enum clang_ext_Final_spelling v)
{
switch (v) {
case clang_ext_Final_Keyword_final: return Val_int(0);
case clang_ext_Final_Keyword_sealed: return Val_int(1);
case clang_ext_Final_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_final_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Final_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Final_spelling result = clang_ext_Final_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_final_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_FlagEnum_spelling
Clang_ext_flagenum_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_FlagEnum_GNU_flag_enum;
case 1: return clang_ext_FlagEnum_CXX11_clang_flag_enum;
case 2: return clang_ext_FlagEnum_C2x_clang_flag_enum;
case 3: return clang_ext_FlagEnum_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_flagenum_spelling_val: %d", Int_val(ocaml));
return clang_ext_FlagEnum_GNU_flag_enum;
}
value
Val_clang_ext_flagenum_spelling(enum clang_ext_FlagEnum_spelling v)
{
switch (v) {
case clang_ext_FlagEnum_GNU_flag_enum: return Val_int(0);
case clang_ext_FlagEnum_CXX11_clang_flag_enum: return Val_int(1);
case clang_ext_FlagEnum_C2x_clang_flag_enum: return Val_int(2);
case clang_ext_FlagEnum_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_flagenum_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_FlagEnum_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_FlagEnum_spelling result = clang_ext_FlagEnum_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_flagenum_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Flatten_spelling
Clang_ext_flatten_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Flatten_GNU_flatten;
case 1: return clang_ext_Flatten_CXX11_gnu_flatten;
case 2: return clang_ext_Flatten_C2x_gnu_flatten;
case 3: return clang_ext_Flatten_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_flatten_spelling_val: %d", Int_val(ocaml));
return clang_ext_Flatten_GNU_flatten;
}
value
Val_clang_ext_flatten_spelling(enum clang_ext_Flatten_spelling v)
{
switch (v) {
case clang_ext_Flatten_GNU_flatten: return Val_int(0);
case clang_ext_Flatten_CXX11_gnu_flatten: return Val_int(1);
case clang_ext_Flatten_C2x_gnu_flatten: return Val_int(2);
case clang_ext_Flatten_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_flatten_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Flatten_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Flatten_spelling result = clang_ext_Flatten_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_flatten_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Format_spelling
Clang_ext_format_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Format_GNU_format;
case 1: return clang_ext_Format_CXX11_gnu_format;
case 2: return clang_ext_Format_C2x_gnu_format;
case 3: return clang_ext_Format_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_format_spelling_val: %d", Int_val(ocaml));
return clang_ext_Format_GNU_format;
}
value
Val_clang_ext_format_spelling(enum clang_ext_Format_spelling v)
{
switch (v) {
case clang_ext_Format_GNU_format: return Val_int(0);
case clang_ext_Format_CXX11_gnu_format: return Val_int(1);
case clang_ext_Format_C2x_gnu_format: return Val_int(2);
case clang_ext_Format_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_format_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Format_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Format_spelling result = clang_ext_Format_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_format_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_FormatArg_spelling
Clang_ext_formatarg_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_FormatArg_GNU_format_arg;
case 1: return clang_ext_FormatArg_CXX11_gnu_format_arg;
case 2: return clang_ext_FormatArg_C2x_gnu_format_arg;
case 3: return clang_ext_FormatArg_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_formatarg_spelling_val: %d", Int_val(ocaml));
return clang_ext_FormatArg_GNU_format_arg;
}
value
Val_clang_ext_formatarg_spelling(enum clang_ext_FormatArg_spelling v)
{
switch (v) {
case clang_ext_FormatArg_GNU_format_arg: return Val_int(0);
case clang_ext_FormatArg_CXX11_gnu_format_arg: return Val_int(1);
case clang_ext_FormatArg_C2x_gnu_format_arg: return Val_int(2);
case clang_ext_FormatArg_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_formatarg_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_FormatArg_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_FormatArg_spelling result = clang_ext_FormatArg_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_formatarg_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_FunctionReturnThunks_spelling
Clang_ext_functionreturnthunks_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_FunctionReturnThunks_GNU_function_return;
case 1: return clang_ext_FunctionReturnThunks_CXX11_gnu_function_return;
case 2: return clang_ext_FunctionReturnThunks_C2x_gnu_function_return;
case 3: return clang_ext_FunctionReturnThunks_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_functionreturnthunks_spelling_val: %d", Int_val(ocaml));
return clang_ext_FunctionReturnThunks_GNU_function_return;
}
value
Val_clang_ext_functionreturnthunks_spelling(enum clang_ext_FunctionReturnThunks_spelling v)
{
switch (v) {
case clang_ext_FunctionReturnThunks_GNU_function_return: return Val_int(0);
case clang_ext_FunctionReturnThunks_CXX11_gnu_function_return: return Val_int(1);
case clang_ext_FunctionReturnThunks_C2x_gnu_function_return: return Val_int(2);
case clang_ext_FunctionReturnThunks_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_functionreturnthunks_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_FunctionReturnThunks_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_FunctionReturnThunks_spelling result = clang_ext_FunctionReturnThunks_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_functionreturnthunks_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_GNUInline_spelling
Clang_ext_gnuinline_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_GNUInline_GNU_gnu_inline;
case 1: return clang_ext_GNUInline_CXX11_gnu_gnu_inline;
case 2: return clang_ext_GNUInline_C2x_gnu_gnu_inline;
case 3: return clang_ext_GNUInline_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_gnuinline_spelling_val: %d", Int_val(ocaml));
return clang_ext_GNUInline_GNU_gnu_inline;
}
value
Val_clang_ext_gnuinline_spelling(enum clang_ext_GNUInline_spelling v)
{
switch (v) {
case clang_ext_GNUInline_GNU_gnu_inline: return Val_int(0);
case clang_ext_GNUInline_CXX11_gnu_gnu_inline: return Val_int(1);
case clang_ext_GNUInline_C2x_gnu_gnu_inline: return Val_int(2);
case clang_ext_GNUInline_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_gnuinline_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_GNUInline_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_GNUInline_spelling result = clang_ext_GNUInline_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_gnuinline_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_GuardedVar_spelling
Clang_ext_guardedvar_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_GuardedVar_GNU_guarded_var;
case 1: return clang_ext_GuardedVar_CXX11_clang_guarded_var;
case 2: return clang_ext_GuardedVar_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_guardedvar_spelling_val: %d", Int_val(ocaml));
return clang_ext_GuardedVar_GNU_guarded_var;
}
value
Val_clang_ext_guardedvar_spelling(enum clang_ext_GuardedVar_spelling v)
{
switch (v) {
case clang_ext_GuardedVar_GNU_guarded_var: return Val_int(0);
case clang_ext_GuardedVar_CXX11_clang_guarded_var: return Val_int(1);
case clang_ext_GuardedVar_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_guardedvar_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_GuardedVar_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_GuardedVar_spelling result = clang_ext_GuardedVar_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_guardedvar_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_HIPManaged_spelling
Clang_ext_hipmanaged_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_HIPManaged_GNU_managed;
case 1: return clang_ext_HIPManaged_Declspec_managed;
case 2: return clang_ext_HIPManaged_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_hipmanaged_spelling_val: %d", Int_val(ocaml));
return clang_ext_HIPManaged_GNU_managed;
}
value
Val_clang_ext_hipmanaged_spelling(enum clang_ext_HIPManaged_spelling v)
{
switch (v) {
case clang_ext_HIPManaged_GNU_managed: return Val_int(0);
case clang_ext_HIPManaged_Declspec_managed: return Val_int(1);
case clang_ext_HIPManaged_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_hipmanaged_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_HIPManaged_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_HIPManaged_spelling result = clang_ext_HIPManaged_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_hipmanaged_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Hot_spelling
Clang_ext_hot_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Hot_GNU_hot;
case 1: return clang_ext_Hot_CXX11_gnu_hot;
case 2: return clang_ext_Hot_C2x_gnu_hot;
case 3: return clang_ext_Hot_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_hot_spelling_val: %d", Int_val(ocaml));
return clang_ext_Hot_GNU_hot;
}
value
Val_clang_ext_hot_spelling(enum clang_ext_Hot_spelling v)
{
switch (v) {
case clang_ext_Hot_GNU_hot: return Val_int(0);
case clang_ext_Hot_CXX11_gnu_hot: return Val_int(1);
case clang_ext_Hot_C2x_gnu_hot: return Val_int(2);
case clang_ext_Hot_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_hot_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Hot_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Hot_spelling result = clang_ext_Hot_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_hot_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_IBAction_spelling
Clang_ext_ibaction_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_IBAction_GNU_ibaction;
case 1: return clang_ext_IBAction_CXX11_clang_ibaction;
case 2: return clang_ext_IBAction_C2x_clang_ibaction;
case 3: return clang_ext_IBAction_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_ibaction_spelling_val: %d", Int_val(ocaml));
return clang_ext_IBAction_GNU_ibaction;
}
value
Val_clang_ext_ibaction_spelling(enum clang_ext_IBAction_spelling v)
{
switch (v) {
case clang_ext_IBAction_GNU_ibaction: return Val_int(0);
case clang_ext_IBAction_CXX11_clang_ibaction: return Val_int(1);
case clang_ext_IBAction_C2x_clang_ibaction: return Val_int(2);
case clang_ext_IBAction_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ibaction_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_IBAction_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_IBAction_spelling result = clang_ext_IBAction_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ibaction_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_IBOutlet_spelling
Clang_ext_iboutlet_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_IBOutlet_GNU_iboutlet;
case 1: return clang_ext_IBOutlet_CXX11_clang_iboutlet;
case 2: return clang_ext_IBOutlet_C2x_clang_iboutlet;
case 3: return clang_ext_IBOutlet_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_iboutlet_spelling_val: %d", Int_val(ocaml));
return clang_ext_IBOutlet_GNU_iboutlet;
}
value
Val_clang_ext_iboutlet_spelling(enum clang_ext_IBOutlet_spelling v)
{
switch (v) {
case clang_ext_IBOutlet_GNU_iboutlet: return Val_int(0);
case clang_ext_IBOutlet_CXX11_clang_iboutlet: return Val_int(1);
case clang_ext_IBOutlet_C2x_clang_iboutlet: return Val_int(2);
case clang_ext_IBOutlet_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_iboutlet_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_IBOutlet_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_IBOutlet_spelling result = clang_ext_IBOutlet_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_iboutlet_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_IBOutletCollection_spelling
Clang_ext_iboutletcollection_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_IBOutletCollection_GNU_iboutletcollection;
case 1: return clang_ext_IBOutletCollection_CXX11_clang_iboutletcollection;
case 2: return clang_ext_IBOutletCollection_C2x_clang_iboutletcollection;
case 3: return clang_ext_IBOutletCollection_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_iboutletcollection_spelling_val: %d", Int_val(ocaml));
return clang_ext_IBOutletCollection_GNU_iboutletcollection;
}
value
Val_clang_ext_iboutletcollection_spelling(enum clang_ext_IBOutletCollection_spelling v)
{
switch (v) {
case clang_ext_IBOutletCollection_GNU_iboutletcollection: return Val_int(0);
case clang_ext_IBOutletCollection_CXX11_clang_iboutletcollection: return Val_int(1);
case clang_ext_IBOutletCollection_C2x_clang_iboutletcollection: return Val_int(2);
case clang_ext_IBOutletCollection_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_iboutletcollection_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_IBOutletCollection_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_IBOutletCollection_spelling result = clang_ext_IBOutletCollection_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_iboutletcollection_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_IFunc_spelling
Clang_ext_ifunc_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_IFunc_GNU_ifunc;
case 1: return clang_ext_IFunc_CXX11_gnu_ifunc;
case 2: return clang_ext_IFunc_C2x_gnu_ifunc;
case 3: return clang_ext_IFunc_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_ifunc_spelling_val: %d", Int_val(ocaml));
return clang_ext_IFunc_GNU_ifunc;
}
value
Val_clang_ext_ifunc_spelling(enum clang_ext_IFunc_spelling v)
{
switch (v) {
case clang_ext_IFunc_GNU_ifunc: return Val_int(0);
case clang_ext_IFunc_CXX11_gnu_ifunc: return Val_int(1);
case clang_ext_IFunc_C2x_gnu_ifunc: return Val_int(2);
case clang_ext_IFunc_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ifunc_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_IFunc_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_IFunc_spelling result = clang_ext_IFunc_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ifunc_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_InitPriority_spelling
Clang_ext_initpriority_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_InitPriority_GNU_init_priority;
case 1: return clang_ext_InitPriority_CXX11_gnu_init_priority;
case 2: return clang_ext_InitPriority_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_initpriority_spelling_val: %d", Int_val(ocaml));
return clang_ext_InitPriority_GNU_init_priority;
}
value
Val_clang_ext_initpriority_spelling(enum clang_ext_InitPriority_spelling v)
{
switch (v) {
case clang_ext_InitPriority_GNU_init_priority: return Val_int(0);
case clang_ext_InitPriority_CXX11_gnu_init_priority: return Val_int(1);
case clang_ext_InitPriority_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_initpriority_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_InitPriority_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_InitPriority_spelling result = clang_ext_InitPriority_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_initpriority_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_IntelOclBicc_spelling
Clang_ext_inteloclbicc_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_IntelOclBicc_GNU_intel_ocl_bicc;
case 1: return clang_ext_IntelOclBicc_CXX11_clang_intel_ocl_bicc;
case 2: return clang_ext_IntelOclBicc_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_inteloclbicc_spelling_val: %d", Int_val(ocaml));
return clang_ext_IntelOclBicc_GNU_intel_ocl_bicc;
}
value
Val_clang_ext_inteloclbicc_spelling(enum clang_ext_IntelOclBicc_spelling v)
{
switch (v) {
case clang_ext_IntelOclBicc_GNU_intel_ocl_bicc: return Val_int(0);
case clang_ext_IntelOclBicc_CXX11_clang_intel_ocl_bicc: return Val_int(1);
case clang_ext_IntelOclBicc_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_inteloclbicc_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_IntelOclBicc_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_IntelOclBicc_spelling result = clang_ext_IntelOclBicc_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_inteloclbicc_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_InternalLinkage_spelling
Clang_ext_internallinkage_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_InternalLinkage_GNU_internal_linkage;
case 1: return clang_ext_InternalLinkage_CXX11_clang_internal_linkage;
case 2: return clang_ext_InternalLinkage_C2x_clang_internal_linkage;
case 3: return clang_ext_InternalLinkage_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_internallinkage_spelling_val: %d", Int_val(ocaml));
return clang_ext_InternalLinkage_GNU_internal_linkage;
}
value
Val_clang_ext_internallinkage_spelling(enum clang_ext_InternalLinkage_spelling v)
{
switch (v) {
case clang_ext_InternalLinkage_GNU_internal_linkage: return Val_int(0);
case clang_ext_InternalLinkage_CXX11_clang_internal_linkage: return Val_int(1);
case clang_ext_InternalLinkage_C2x_clang_internal_linkage: return Val_int(2);
case clang_ext_InternalLinkage_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_internallinkage_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_InternalLinkage_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_InternalLinkage_spelling result = clang_ext_InternalLinkage_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_internallinkage_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_LTOVisibilityPublic_spelling
Clang_ext_ltovisibilitypublic_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_LTOVisibilityPublic_GNU_lto_visibility_public;
case 1: return clang_ext_LTOVisibilityPublic_CXX11_clang_lto_visibility_public;
case 2: return clang_ext_LTOVisibilityPublic_C2x_clang_lto_visibility_public;
case 3: return clang_ext_LTOVisibilityPublic_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_ltovisibilitypublic_spelling_val: %d", Int_val(ocaml));
return clang_ext_LTOVisibilityPublic_GNU_lto_visibility_public;
}
value
Val_clang_ext_ltovisibilitypublic_spelling(enum clang_ext_LTOVisibilityPublic_spelling v)
{
switch (v) {
case clang_ext_LTOVisibilityPublic_GNU_lto_visibility_public: return Val_int(0);
case clang_ext_LTOVisibilityPublic_CXX11_clang_lto_visibility_public: return Val_int(1);
case clang_ext_LTOVisibilityPublic_C2x_clang_lto_visibility_public: return Val_int(2);
case clang_ext_LTOVisibilityPublic_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ltovisibilitypublic_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LTOVisibilityPublic_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_LTOVisibilityPublic_spelling result = clang_ext_LTOVisibilityPublic_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ltovisibilitypublic_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Leaf_spelling
Clang_ext_leaf_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Leaf_GNU_leaf;
case 1: return clang_ext_Leaf_CXX11_gnu_leaf;
case 2: return clang_ext_Leaf_C2x_gnu_leaf;
case 3: return clang_ext_Leaf_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_leaf_spelling_val: %d", Int_val(ocaml));
return clang_ext_Leaf_GNU_leaf;
}
value
Val_clang_ext_leaf_spelling(enum clang_ext_Leaf_spelling v)
{
switch (v) {
case clang_ext_Leaf_GNU_leaf: return Val_int(0);
case clang_ext_Leaf_CXX11_gnu_leaf: return Val_int(1);
case clang_ext_Leaf_C2x_gnu_leaf: return Val_int(2);
case clang_ext_Leaf_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_leaf_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Leaf_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Leaf_spelling result = clang_ext_Leaf_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_leaf_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_LifetimeBound_spelling
Clang_ext_lifetimebound_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_LifetimeBound_GNU_lifetimebound;
case 1: return clang_ext_LifetimeBound_CXX11_clang_lifetimebound;
case 2: return clang_ext_LifetimeBound_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_lifetimebound_spelling_val: %d", Int_val(ocaml));
return clang_ext_LifetimeBound_GNU_lifetimebound;
}
value
Val_clang_ext_lifetimebound_spelling(enum clang_ext_LifetimeBound_spelling v)
{
switch (v) {
case clang_ext_LifetimeBound_GNU_lifetimebound: return Val_int(0);
case clang_ext_LifetimeBound_CXX11_clang_lifetimebound: return Val_int(1);
case clang_ext_LifetimeBound_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_lifetimebound_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LifetimeBound_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_LifetimeBound_spelling result = clang_ext_LifetimeBound_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_lifetimebound_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Likely_spelling
Clang_ext_likely_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Likely_CXX11_likely;
case 1: return clang_ext_Likely_C2x_clang_likely;
case 2: return clang_ext_Likely_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_likely_spelling_val: %d", Int_val(ocaml));
return clang_ext_Likely_CXX11_likely;
}
value
Val_clang_ext_likely_spelling(enum clang_ext_Likely_spelling v)
{
switch (v) {
case clang_ext_Likely_CXX11_likely: return Val_int(0);
case clang_ext_Likely_C2x_clang_likely: return Val_int(1);
case clang_ext_Likely_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_likely_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Likely_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Likely_spelling result = clang_ext_Likely_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_likely_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_LoaderUninitialized_spelling
Clang_ext_loaderuninitialized_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_LoaderUninitialized_GNU_loader_uninitialized;
case 1: return clang_ext_LoaderUninitialized_CXX11_clang_loader_uninitialized;
case 2: return clang_ext_LoaderUninitialized_C2x_clang_loader_uninitialized;
case 3: return clang_ext_LoaderUninitialized_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_loaderuninitialized_spelling_val: %d", Int_val(ocaml));
return clang_ext_LoaderUninitialized_GNU_loader_uninitialized;
}
value
Val_clang_ext_loaderuninitialized_spelling(enum clang_ext_LoaderUninitialized_spelling v)
{
switch (v) {
case clang_ext_LoaderUninitialized_GNU_loader_uninitialized: return Val_int(0);
case clang_ext_LoaderUninitialized_CXX11_clang_loader_uninitialized: return Val_int(1);
case clang_ext_LoaderUninitialized_C2x_clang_loader_uninitialized: return Val_int(2);
case clang_ext_LoaderUninitialized_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_loaderuninitialized_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LoaderUninitialized_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_LoaderUninitialized_spelling result = clang_ext_LoaderUninitialized_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_loaderuninitialized_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_LoopHint_spelling
Clang_ext_loophint_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_LoopHint_Pragma_clang_loop;
case 1: return clang_ext_LoopHint_Pragma_unroll;
case 2: return clang_ext_LoopHint_Pragma_nounroll;
case 3: return clang_ext_LoopHint_Pragma_unroll_and_jam;
case 4: return clang_ext_LoopHint_Pragma_nounroll_and_jam;
case 5: return clang_ext_LoopHint_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_loophint_spelling_val: %d", Int_val(ocaml));
return clang_ext_LoopHint_Pragma_clang_loop;
}
value
Val_clang_ext_loophint_spelling(enum clang_ext_LoopHint_spelling v)
{
switch (v) {
case clang_ext_LoopHint_Pragma_clang_loop: return Val_int(0);
case clang_ext_LoopHint_Pragma_unroll: return Val_int(1);
case clang_ext_LoopHint_Pragma_nounroll: return Val_int(2);
case clang_ext_LoopHint_Pragma_unroll_and_jam: return Val_int(3);
case clang_ext_LoopHint_Pragma_nounroll_and_jam: return Val_int(4);
case clang_ext_LoopHint_SpellingNotCalculated: return Val_int(5);
}
caml_failwith_fmt("invalid value for Val_clang_ext_loophint_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LoopHint_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_LoopHint_spelling result = clang_ext_LoopHint_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_loophint_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MIGServerRoutine_spelling
Clang_ext_migserverroutine_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MIGServerRoutine_GNU_mig_server_routine;
case 1: return clang_ext_MIGServerRoutine_CXX11_clang_mig_server_routine;
case 2: return clang_ext_MIGServerRoutine_C2x_clang_mig_server_routine;
case 3: return clang_ext_MIGServerRoutine_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_migserverroutine_spelling_val: %d", Int_val(ocaml));
return clang_ext_MIGServerRoutine_GNU_mig_server_routine;
}
value
Val_clang_ext_migserverroutine_spelling(enum clang_ext_MIGServerRoutine_spelling v)
{
switch (v) {
case clang_ext_MIGServerRoutine_GNU_mig_server_routine: return Val_int(0);
case clang_ext_MIGServerRoutine_CXX11_clang_mig_server_routine: return Val_int(1);
case clang_ext_MIGServerRoutine_C2x_clang_mig_server_routine: return Val_int(2);
case clang_ext_MIGServerRoutine_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_migserverroutine_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MIGServerRoutine_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MIGServerRoutine_spelling result = clang_ext_MIGServerRoutine_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_migserverroutine_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MSABI_spelling
Clang_ext_msabi_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MSABI_GNU_ms_abi;
case 1: return clang_ext_MSABI_CXX11_gnu_ms_abi;
case 2: return clang_ext_MSABI_C2x_gnu_ms_abi;
case 3: return clang_ext_MSABI_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_msabi_spelling_val: %d", Int_val(ocaml));
return clang_ext_MSABI_GNU_ms_abi;
}
value
Val_clang_ext_msabi_spelling(enum clang_ext_MSABI_spelling v)
{
switch (v) {
case clang_ext_MSABI_GNU_ms_abi: return Val_int(0);
case clang_ext_MSABI_CXX11_gnu_ms_abi: return Val_int(1);
case clang_ext_MSABI_C2x_gnu_ms_abi: return Val_int(2);
case clang_ext_MSABI_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_msabi_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MSABI_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MSABI_spelling result = clang_ext_MSABI_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_msabi_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MSInheritance_spelling
Clang_ext_msinheritance_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MSInheritance_Keyword_single_inheritance;
case 1: return clang_ext_MSInheritance_Keyword_multiple_inheritance;
case 2: return clang_ext_MSInheritance_Keyword_virtual_inheritance;
case 3: return clang_ext_MSInheritance_Keyword_unspecified_inheritance;
case 4: return clang_ext_MSInheritance_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_msinheritance_spelling_val: %d", Int_val(ocaml));
return clang_ext_MSInheritance_Keyword_single_inheritance;
}
value
Val_clang_ext_msinheritance_spelling(enum clang_ext_MSInheritance_spelling v)
{
switch (v) {
case clang_ext_MSInheritance_Keyword_single_inheritance: return Val_int(0);
case clang_ext_MSInheritance_Keyword_multiple_inheritance: return Val_int(1);
case clang_ext_MSInheritance_Keyword_virtual_inheritance: return Val_int(2);
case clang_ext_MSInheritance_Keyword_unspecified_inheritance: return Val_int(3);
case clang_ext_MSInheritance_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_msinheritance_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MSInheritance_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MSInheritance_spelling result = clang_ext_MSInheritance_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_msinheritance_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MSP430Interrupt_spelling
Clang_ext_msp430interrupt_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MSP430Interrupt_GNU_interrupt;
case 1: return clang_ext_MSP430Interrupt_CXX11_gnu_interrupt;
case 2: return clang_ext_MSP430Interrupt_C2x_gnu_interrupt;
case 3: return clang_ext_MSP430Interrupt_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_msp430interrupt_spelling_val: %d", Int_val(ocaml));
return clang_ext_MSP430Interrupt_GNU_interrupt;
}
value
Val_clang_ext_msp430interrupt_spelling(enum clang_ext_MSP430Interrupt_spelling v)
{
switch (v) {
case clang_ext_MSP430Interrupt_GNU_interrupt: return Val_int(0);
case clang_ext_MSP430Interrupt_CXX11_gnu_interrupt: return Val_int(1);
case clang_ext_MSP430Interrupt_C2x_gnu_interrupt: return Val_int(2);
case clang_ext_MSP430Interrupt_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_msp430interrupt_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MSP430Interrupt_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MSP430Interrupt_spelling result = clang_ext_MSP430Interrupt_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_msp430interrupt_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MSStruct_spelling
Clang_ext_msstruct_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MSStruct_GNU_ms_struct;
case 1: return clang_ext_MSStruct_CXX11_gnu_ms_struct;
case 2: return clang_ext_MSStruct_C2x_gnu_ms_struct;
case 3: return clang_ext_MSStruct_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_msstruct_spelling_val: %d", Int_val(ocaml));
return clang_ext_MSStruct_GNU_ms_struct;
}
value
Val_clang_ext_msstruct_spelling(enum clang_ext_MSStruct_spelling v)
{
switch (v) {
case clang_ext_MSStruct_GNU_ms_struct: return Val_int(0);
case clang_ext_MSStruct_CXX11_gnu_ms_struct: return Val_int(1);
case clang_ext_MSStruct_C2x_gnu_ms_struct: return Val_int(2);
case clang_ext_MSStruct_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_msstruct_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MSStruct_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MSStruct_spelling result = clang_ext_MSStruct_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_msstruct_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MayAlias_spelling
Clang_ext_mayalias_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MayAlias_GNU_may_alias;
case 1: return clang_ext_MayAlias_CXX11_gnu_may_alias;
case 2: return clang_ext_MayAlias_C2x_gnu_may_alias;
case 3: return clang_ext_MayAlias_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_mayalias_spelling_val: %d", Int_val(ocaml));
return clang_ext_MayAlias_GNU_may_alias;
}
value
Val_clang_ext_mayalias_spelling(enum clang_ext_MayAlias_spelling v)
{
switch (v) {
case clang_ext_MayAlias_GNU_may_alias: return Val_int(0);
case clang_ext_MayAlias_CXX11_gnu_may_alias: return Val_int(1);
case clang_ext_MayAlias_C2x_gnu_may_alias: return Val_int(2);
case clang_ext_MayAlias_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_mayalias_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MayAlias_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MayAlias_spelling result = clang_ext_MayAlias_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_mayalias_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MicroMips_spelling
Clang_ext_micromips_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MicroMips_GNU_micromips;
case 1: return clang_ext_MicroMips_CXX11_gnu_micromips;
case 2: return clang_ext_MicroMips_C2x_gnu_micromips;
case 3: return clang_ext_MicroMips_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_micromips_spelling_val: %d", Int_val(ocaml));
return clang_ext_MicroMips_GNU_micromips;
}
value
Val_clang_ext_micromips_spelling(enum clang_ext_MicroMips_spelling v)
{
switch (v) {
case clang_ext_MicroMips_GNU_micromips: return Val_int(0);
case clang_ext_MicroMips_CXX11_gnu_micromips: return Val_int(1);
case clang_ext_MicroMips_C2x_gnu_micromips: return Val_int(2);
case clang_ext_MicroMips_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_micromips_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MicroMips_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MicroMips_spelling result = clang_ext_MicroMips_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_micromips_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MinSize_spelling
Clang_ext_minsize_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MinSize_GNU_minsize;
case 1: return clang_ext_MinSize_CXX11_clang_minsize;
case 2: return clang_ext_MinSize_C2x_clang_minsize;
case 3: return clang_ext_MinSize_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_minsize_spelling_val: %d", Int_val(ocaml));
return clang_ext_MinSize_GNU_minsize;
}
value
Val_clang_ext_minsize_spelling(enum clang_ext_MinSize_spelling v)
{
switch (v) {
case clang_ext_MinSize_GNU_minsize: return Val_int(0);
case clang_ext_MinSize_CXX11_clang_minsize: return Val_int(1);
case clang_ext_MinSize_C2x_clang_minsize: return Val_int(2);
case clang_ext_MinSize_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_minsize_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MinSize_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MinSize_spelling result = clang_ext_MinSize_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_minsize_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MinVectorWidth_spelling
Clang_ext_minvectorwidth_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MinVectorWidth_GNU_min_vector_width;
case 1: return clang_ext_MinVectorWidth_CXX11_clang_min_vector_width;
case 2: return clang_ext_MinVectorWidth_C2x_clang_min_vector_width;
case 3: return clang_ext_MinVectorWidth_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_minvectorwidth_spelling_val: %d", Int_val(ocaml));
return clang_ext_MinVectorWidth_GNU_min_vector_width;
}
value
Val_clang_ext_minvectorwidth_spelling(enum clang_ext_MinVectorWidth_spelling v)
{
switch (v) {
case clang_ext_MinVectorWidth_GNU_min_vector_width: return Val_int(0);
case clang_ext_MinVectorWidth_CXX11_clang_min_vector_width: return Val_int(1);
case clang_ext_MinVectorWidth_C2x_clang_min_vector_width: return Val_int(2);
case clang_ext_MinVectorWidth_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_minvectorwidth_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MinVectorWidth_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MinVectorWidth_spelling result = clang_ext_MinVectorWidth_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_minvectorwidth_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Mips16_spelling
Clang_ext_mips16_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Mips16_GNU_mips16;
case 1: return clang_ext_Mips16_CXX11_gnu_mips16;
case 2: return clang_ext_Mips16_C2x_gnu_mips16;
case 3: return clang_ext_Mips16_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_mips16_spelling_val: %d", Int_val(ocaml));
return clang_ext_Mips16_GNU_mips16;
}
value
Val_clang_ext_mips16_spelling(enum clang_ext_Mips16_spelling v)
{
switch (v) {
case clang_ext_Mips16_GNU_mips16: return Val_int(0);
case clang_ext_Mips16_CXX11_gnu_mips16: return Val_int(1);
case clang_ext_Mips16_C2x_gnu_mips16: return Val_int(2);
case clang_ext_Mips16_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_mips16_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Mips16_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Mips16_spelling result = clang_ext_Mips16_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_mips16_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MipsInterrupt_spelling
Clang_ext_mipsinterrupt_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MipsInterrupt_GNU_interrupt;
case 1: return clang_ext_MipsInterrupt_CXX11_gnu_interrupt;
case 2: return clang_ext_MipsInterrupt_C2x_gnu_interrupt;
case 3: return clang_ext_MipsInterrupt_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_mipsinterrupt_spelling_val: %d", Int_val(ocaml));
return clang_ext_MipsInterrupt_GNU_interrupt;
}
value
Val_clang_ext_mipsinterrupt_spelling(enum clang_ext_MipsInterrupt_spelling v)
{
switch (v) {
case clang_ext_MipsInterrupt_GNU_interrupt: return Val_int(0);
case clang_ext_MipsInterrupt_CXX11_gnu_interrupt: return Val_int(1);
case clang_ext_MipsInterrupt_C2x_gnu_interrupt: return Val_int(2);
case clang_ext_MipsInterrupt_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_mipsinterrupt_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MipsInterrupt_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MipsInterrupt_spelling result = clang_ext_MipsInterrupt_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_mipsinterrupt_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MipsLongCall_spelling
Clang_ext_mipslongcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MipsLongCall_GNU_long_call;
case 1: return clang_ext_MipsLongCall_CXX11_gnu_long_call;
case 2: return clang_ext_MipsLongCall_C2x_gnu_long_call;
case 3: return clang_ext_MipsLongCall_GNU_far;
case 4: return clang_ext_MipsLongCall_CXX11_gnu_far;
case 5: return clang_ext_MipsLongCall_C2x_gnu_far;
case 6: return clang_ext_MipsLongCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_mipslongcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_MipsLongCall_GNU_long_call;
}
value
Val_clang_ext_mipslongcall_spelling(enum clang_ext_MipsLongCall_spelling v)
{
switch (v) {
case clang_ext_MipsLongCall_GNU_long_call: return Val_int(0);
case clang_ext_MipsLongCall_CXX11_gnu_long_call: return Val_int(1);
case clang_ext_MipsLongCall_C2x_gnu_long_call: return Val_int(2);
case clang_ext_MipsLongCall_GNU_far: return Val_int(3);
case clang_ext_MipsLongCall_CXX11_gnu_far: return Val_int(4);
case clang_ext_MipsLongCall_C2x_gnu_far: return Val_int(5);
case clang_ext_MipsLongCall_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_mipslongcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MipsLongCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MipsLongCall_spelling result = clang_ext_MipsLongCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_mipslongcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MipsShortCall_spelling
Clang_ext_mipsshortcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MipsShortCall_GNU_short_call;
case 1: return clang_ext_MipsShortCall_CXX11_gnu_short_call;
case 2: return clang_ext_MipsShortCall_C2x_gnu_short_call;
case 3: return clang_ext_MipsShortCall_GNU_near;
case 4: return clang_ext_MipsShortCall_CXX11_gnu_near;
case 5: return clang_ext_MipsShortCall_C2x_gnu_near;
case 6: return clang_ext_MipsShortCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_mipsshortcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_MipsShortCall_GNU_short_call;
}
value
Val_clang_ext_mipsshortcall_spelling(enum clang_ext_MipsShortCall_spelling v)
{
switch (v) {
case clang_ext_MipsShortCall_GNU_short_call: return Val_int(0);
case clang_ext_MipsShortCall_CXX11_gnu_short_call: return Val_int(1);
case clang_ext_MipsShortCall_C2x_gnu_short_call: return Val_int(2);
case clang_ext_MipsShortCall_GNU_near: return Val_int(3);
case clang_ext_MipsShortCall_CXX11_gnu_near: return Val_int(4);
case clang_ext_MipsShortCall_C2x_gnu_near: return Val_int(5);
case clang_ext_MipsShortCall_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_mipsshortcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MipsShortCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MipsShortCall_spelling result = clang_ext_MipsShortCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_mipsshortcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Mode_spelling
Clang_ext_mode_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Mode_GNU_mode;
case 1: return clang_ext_Mode_CXX11_gnu_mode;
case 2: return clang_ext_Mode_C2x_gnu_mode;
case 3: return clang_ext_Mode_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_mode_spelling_val: %d", Int_val(ocaml));
return clang_ext_Mode_GNU_mode;
}
value
Val_clang_ext_mode_spelling(enum clang_ext_Mode_spelling v)
{
switch (v) {
case clang_ext_Mode_GNU_mode: return Val_int(0);
case clang_ext_Mode_CXX11_gnu_mode: return Val_int(1);
case clang_ext_Mode_C2x_gnu_mode: return Val_int(2);
case clang_ext_Mode_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_mode_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Mode_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Mode_spelling result = clang_ext_Mode_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_mode_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_MustTail_spelling
Clang_ext_musttail_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MustTail_GNU_musttail;
case 1: return clang_ext_MustTail_CXX11_clang_musttail;
case 2: return clang_ext_MustTail_C2x_clang_musttail;
case 3: return clang_ext_MustTail_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_musttail_spelling_val: %d", Int_val(ocaml));
return clang_ext_MustTail_GNU_musttail;
}
value
Val_clang_ext_musttail_spelling(enum clang_ext_MustTail_spelling v)
{
switch (v) {
case clang_ext_MustTail_GNU_musttail: return Val_int(0);
case clang_ext_MustTail_CXX11_clang_musttail: return Val_int(1);
case clang_ext_MustTail_C2x_clang_musttail: return Val_int(2);
case clang_ext_MustTail_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_musttail_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MustTail_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MustTail_spelling result = clang_ext_MustTail_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_musttail_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NSConsumed_spelling
Clang_ext_nsconsumed_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NSConsumed_GNU_ns_consumed;
case 1: return clang_ext_NSConsumed_CXX11_clang_ns_consumed;
case 2: return clang_ext_NSConsumed_C2x_clang_ns_consumed;
case 3: return clang_ext_NSConsumed_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nsconsumed_spelling_val: %d", Int_val(ocaml));
return clang_ext_NSConsumed_GNU_ns_consumed;
}
value
Val_clang_ext_nsconsumed_spelling(enum clang_ext_NSConsumed_spelling v)
{
switch (v) {
case clang_ext_NSConsumed_GNU_ns_consumed: return Val_int(0);
case clang_ext_NSConsumed_CXX11_clang_ns_consumed: return Val_int(1);
case clang_ext_NSConsumed_C2x_clang_ns_consumed: return Val_int(2);
case clang_ext_NSConsumed_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nsconsumed_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NSConsumed_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NSConsumed_spelling result = clang_ext_NSConsumed_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nsconsumed_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NSConsumesSelf_spelling
Clang_ext_nsconsumesself_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NSConsumesSelf_GNU_ns_consumes_self;
case 1: return clang_ext_NSConsumesSelf_CXX11_clang_ns_consumes_self;
case 2: return clang_ext_NSConsumesSelf_C2x_clang_ns_consumes_self;
case 3: return clang_ext_NSConsumesSelf_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nsconsumesself_spelling_val: %d", Int_val(ocaml));
return clang_ext_NSConsumesSelf_GNU_ns_consumes_self;
}
value
Val_clang_ext_nsconsumesself_spelling(enum clang_ext_NSConsumesSelf_spelling v)
{
switch (v) {
case clang_ext_NSConsumesSelf_GNU_ns_consumes_self: return Val_int(0);
case clang_ext_NSConsumesSelf_CXX11_clang_ns_consumes_self: return Val_int(1);
case clang_ext_NSConsumesSelf_C2x_clang_ns_consumes_self: return Val_int(2);
case clang_ext_NSConsumesSelf_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nsconsumesself_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NSConsumesSelf_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NSConsumesSelf_spelling result = clang_ext_NSConsumesSelf_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nsconsumesself_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NSReturnsAutoreleased_spelling
Clang_ext_nsreturnsautoreleased_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NSReturnsAutoreleased_GNU_ns_returns_autoreleased;
case 1: return clang_ext_NSReturnsAutoreleased_CXX11_clang_ns_returns_autoreleased;
case 2: return clang_ext_NSReturnsAutoreleased_C2x_clang_ns_returns_autoreleased;
case 3: return clang_ext_NSReturnsAutoreleased_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nsreturnsautoreleased_spelling_val: %d", Int_val(ocaml));
return clang_ext_NSReturnsAutoreleased_GNU_ns_returns_autoreleased;
}
value
Val_clang_ext_nsreturnsautoreleased_spelling(enum clang_ext_NSReturnsAutoreleased_spelling v)
{
switch (v) {
case clang_ext_NSReturnsAutoreleased_GNU_ns_returns_autoreleased: return Val_int(0);
case clang_ext_NSReturnsAutoreleased_CXX11_clang_ns_returns_autoreleased: return Val_int(1);
case clang_ext_NSReturnsAutoreleased_C2x_clang_ns_returns_autoreleased: return Val_int(2);
case clang_ext_NSReturnsAutoreleased_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nsreturnsautoreleased_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NSReturnsAutoreleased_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NSReturnsAutoreleased_spelling result = clang_ext_NSReturnsAutoreleased_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nsreturnsautoreleased_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NSReturnsNotRetained_spelling
Clang_ext_nsreturnsnotretained_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NSReturnsNotRetained_GNU_ns_returns_not_retained;
case 1: return clang_ext_NSReturnsNotRetained_CXX11_clang_ns_returns_not_retained;
case 2: return clang_ext_NSReturnsNotRetained_C2x_clang_ns_returns_not_retained;
case 3: return clang_ext_NSReturnsNotRetained_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nsreturnsnotretained_spelling_val: %d", Int_val(ocaml));
return clang_ext_NSReturnsNotRetained_GNU_ns_returns_not_retained;
}
value
Val_clang_ext_nsreturnsnotretained_spelling(enum clang_ext_NSReturnsNotRetained_spelling v)
{
switch (v) {
case clang_ext_NSReturnsNotRetained_GNU_ns_returns_not_retained: return Val_int(0);
case clang_ext_NSReturnsNotRetained_CXX11_clang_ns_returns_not_retained: return Val_int(1);
case clang_ext_NSReturnsNotRetained_C2x_clang_ns_returns_not_retained: return Val_int(2);
case clang_ext_NSReturnsNotRetained_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nsreturnsnotretained_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NSReturnsNotRetained_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NSReturnsNotRetained_spelling result = clang_ext_NSReturnsNotRetained_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nsreturnsnotretained_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NSReturnsRetained_spelling
Clang_ext_nsreturnsretained_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NSReturnsRetained_GNU_ns_returns_retained;
case 1: return clang_ext_NSReturnsRetained_CXX11_clang_ns_returns_retained;
case 2: return clang_ext_NSReturnsRetained_C2x_clang_ns_returns_retained;
case 3: return clang_ext_NSReturnsRetained_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nsreturnsretained_spelling_val: %d", Int_val(ocaml));
return clang_ext_NSReturnsRetained_GNU_ns_returns_retained;
}
value
Val_clang_ext_nsreturnsretained_spelling(enum clang_ext_NSReturnsRetained_spelling v)
{
switch (v) {
case clang_ext_NSReturnsRetained_GNU_ns_returns_retained: return Val_int(0);
case clang_ext_NSReturnsRetained_CXX11_clang_ns_returns_retained: return Val_int(1);
case clang_ext_NSReturnsRetained_C2x_clang_ns_returns_retained: return Val_int(2);
case clang_ext_NSReturnsRetained_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nsreturnsretained_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NSReturnsRetained_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NSReturnsRetained_spelling result = clang_ext_NSReturnsRetained_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nsreturnsretained_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Naked_spelling
Clang_ext_naked_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Naked_GNU_naked;
case 1: return clang_ext_Naked_CXX11_gnu_naked;
case 2: return clang_ext_Naked_C2x_gnu_naked;
case 3: return clang_ext_Naked_Declspec_naked;
case 4: return clang_ext_Naked_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_naked_spelling_val: %d", Int_val(ocaml));
return clang_ext_Naked_GNU_naked;
}
value
Val_clang_ext_naked_spelling(enum clang_ext_Naked_spelling v)
{
switch (v) {
case clang_ext_Naked_GNU_naked: return Val_int(0);
case clang_ext_Naked_CXX11_gnu_naked: return Val_int(1);
case clang_ext_Naked_C2x_gnu_naked: return Val_int(2);
case clang_ext_Naked_Declspec_naked: return Val_int(3);
case clang_ext_Naked_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_naked_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Naked_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Naked_spelling result = clang_ext_Naked_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_naked_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoBuiltin_spelling
Clang_ext_nobuiltin_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoBuiltin_GNU_no_builtin;
case 1: return clang_ext_NoBuiltin_CXX11_clang_no_builtin;
case 2: return clang_ext_NoBuiltin_C2x_clang_no_builtin;
case 3: return clang_ext_NoBuiltin_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nobuiltin_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoBuiltin_GNU_no_builtin;
}
value
Val_clang_ext_nobuiltin_spelling(enum clang_ext_NoBuiltin_spelling v)
{
switch (v) {
case clang_ext_NoBuiltin_GNU_no_builtin: return Val_int(0);
case clang_ext_NoBuiltin_CXX11_clang_no_builtin: return Val_int(1);
case clang_ext_NoBuiltin_C2x_clang_no_builtin: return Val_int(2);
case clang_ext_NoBuiltin_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nobuiltin_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoBuiltin_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoBuiltin_spelling result = clang_ext_NoBuiltin_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nobuiltin_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoCommon_spelling
Clang_ext_nocommon_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoCommon_GNU_nocommon;
case 1: return clang_ext_NoCommon_CXX11_gnu_nocommon;
case 2: return clang_ext_NoCommon_C2x_gnu_nocommon;
case 3: return clang_ext_NoCommon_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nocommon_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoCommon_GNU_nocommon;
}
value
Val_clang_ext_nocommon_spelling(enum clang_ext_NoCommon_spelling v)
{
switch (v) {
case clang_ext_NoCommon_GNU_nocommon: return Val_int(0);
case clang_ext_NoCommon_CXX11_gnu_nocommon: return Val_int(1);
case clang_ext_NoCommon_C2x_gnu_nocommon: return Val_int(2);
case clang_ext_NoCommon_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nocommon_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoCommon_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoCommon_spelling result = clang_ext_NoCommon_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nocommon_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoDebug_spelling
Clang_ext_nodebug_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoDebug_GNU_nodebug;
case 1: return clang_ext_NoDebug_CXX11_gnu_nodebug;
case 2: return clang_ext_NoDebug_C2x_gnu_nodebug;
case 3: return clang_ext_NoDebug_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nodebug_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoDebug_GNU_nodebug;
}
value
Val_clang_ext_nodebug_spelling(enum clang_ext_NoDebug_spelling v)
{
switch (v) {
case clang_ext_NoDebug_GNU_nodebug: return Val_int(0);
case clang_ext_NoDebug_CXX11_gnu_nodebug: return Val_int(1);
case clang_ext_NoDebug_C2x_gnu_nodebug: return Val_int(2);
case clang_ext_NoDebug_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nodebug_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoDebug_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoDebug_spelling result = clang_ext_NoDebug_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nodebug_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoDeref_spelling
Clang_ext_noderef_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoDeref_GNU_noderef;
case 1: return clang_ext_NoDeref_CXX11_clang_noderef;
case 2: return clang_ext_NoDeref_C2x_clang_noderef;
case 3: return clang_ext_NoDeref_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_noderef_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoDeref_GNU_noderef;
}
value
Val_clang_ext_noderef_spelling(enum clang_ext_NoDeref_spelling v)
{
switch (v) {
case clang_ext_NoDeref_GNU_noderef: return Val_int(0);
case clang_ext_NoDeref_CXX11_clang_noderef: return Val_int(1);
case clang_ext_NoDeref_C2x_clang_noderef: return Val_int(2);
case clang_ext_NoDeref_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_noderef_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoDeref_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoDeref_spelling result = clang_ext_NoDeref_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_noderef_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoDestroy_spelling
Clang_ext_nodestroy_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoDestroy_GNU_no_destroy;
case 1: return clang_ext_NoDestroy_CXX11_clang_no_destroy;
case 2: return clang_ext_NoDestroy_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nodestroy_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoDestroy_GNU_no_destroy;
}
value
Val_clang_ext_nodestroy_spelling(enum clang_ext_NoDestroy_spelling v)
{
switch (v) {
case clang_ext_NoDestroy_GNU_no_destroy: return Val_int(0);
case clang_ext_NoDestroy_CXX11_clang_no_destroy: return Val_int(1);
case clang_ext_NoDestroy_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nodestroy_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoDestroy_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoDestroy_spelling result = clang_ext_NoDestroy_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nodestroy_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoDuplicate_spelling
Clang_ext_noduplicate_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoDuplicate_GNU_noduplicate;
case 1: return clang_ext_NoDuplicate_CXX11_clang_noduplicate;
case 2: return clang_ext_NoDuplicate_C2x_clang_noduplicate;
case 3: return clang_ext_NoDuplicate_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_noduplicate_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoDuplicate_GNU_noduplicate;
}
value
Val_clang_ext_noduplicate_spelling(enum clang_ext_NoDuplicate_spelling v)
{
switch (v) {
case clang_ext_NoDuplicate_GNU_noduplicate: return Val_int(0);
case clang_ext_NoDuplicate_CXX11_clang_noduplicate: return Val_int(1);
case clang_ext_NoDuplicate_C2x_clang_noduplicate: return Val_int(2);
case clang_ext_NoDuplicate_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_noduplicate_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoDuplicate_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoDuplicate_spelling result = clang_ext_NoDuplicate_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_noduplicate_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoEscape_spelling
Clang_ext_noescape_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoEscape_GNU_noescape;
case 1: return clang_ext_NoEscape_CXX11_clang_noescape;
case 2: return clang_ext_NoEscape_C2x_clang_noescape;
case 3: return clang_ext_NoEscape_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_noescape_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoEscape_GNU_noescape;
}
value
Val_clang_ext_noescape_spelling(enum clang_ext_NoEscape_spelling v)
{
switch (v) {
case clang_ext_NoEscape_GNU_noescape: return Val_int(0);
case clang_ext_NoEscape_CXX11_clang_noescape: return Val_int(1);
case clang_ext_NoEscape_C2x_clang_noescape: return Val_int(2);
case clang_ext_NoEscape_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_noescape_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoEscape_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoEscape_spelling result = clang_ext_NoEscape_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_noescape_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoInline_spelling
Clang_ext_noinline_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoInline_Keyword_noinline;
case 1: return clang_ext_NoInline_GNU_noinline;
case 2: return clang_ext_NoInline_CXX11_gnu_noinline;
case 3: return clang_ext_NoInline_C2x_gnu_noinline;
case 4: return clang_ext_NoInline_CXX11_clang_noinline;
case 5: return clang_ext_NoInline_C2x_clang_noinline;
case 6: return clang_ext_NoInline_Declspec_noinline;
case 7: return clang_ext_NoInline_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_noinline_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoInline_Keyword_noinline;
}
value
Val_clang_ext_noinline_spelling(enum clang_ext_NoInline_spelling v)
{
switch (v) {
case clang_ext_NoInline_Keyword_noinline: return Val_int(0);
case clang_ext_NoInline_GNU_noinline: return Val_int(1);
case clang_ext_NoInline_CXX11_gnu_noinline: return Val_int(2);
case clang_ext_NoInline_C2x_gnu_noinline: return Val_int(3);
case clang_ext_NoInline_CXX11_clang_noinline: return Val_int(4);
case clang_ext_NoInline_C2x_clang_noinline: return Val_int(5);
case clang_ext_NoInline_Declspec_noinline: return Val_int(6);
case clang_ext_NoInline_SpellingNotCalculated: return Val_int(7);
}
caml_failwith_fmt("invalid value for Val_clang_ext_noinline_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoInline_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoInline_spelling result = clang_ext_NoInline_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_noinline_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoInstrumentFunction_spelling
Clang_ext_noinstrumentfunction_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoInstrumentFunction_GNU_no_instrument_function;
case 1: return clang_ext_NoInstrumentFunction_CXX11_gnu_no_instrument_function;
case 2: return clang_ext_NoInstrumentFunction_C2x_gnu_no_instrument_function;
case 3: return clang_ext_NoInstrumentFunction_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_noinstrumentfunction_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoInstrumentFunction_GNU_no_instrument_function;
}
value
Val_clang_ext_noinstrumentfunction_spelling(enum clang_ext_NoInstrumentFunction_spelling v)
{
switch (v) {
case clang_ext_NoInstrumentFunction_GNU_no_instrument_function: return Val_int(0);
case clang_ext_NoInstrumentFunction_CXX11_gnu_no_instrument_function: return Val_int(1);
case clang_ext_NoInstrumentFunction_C2x_gnu_no_instrument_function: return Val_int(2);
case clang_ext_NoInstrumentFunction_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_noinstrumentfunction_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoInstrumentFunction_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoInstrumentFunction_spelling result = clang_ext_NoInstrumentFunction_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_noinstrumentfunction_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoMerge_spelling
Clang_ext_nomerge_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoMerge_GNU_nomerge;
case 1: return clang_ext_NoMerge_CXX11_clang_nomerge;
case 2: return clang_ext_NoMerge_C2x_clang_nomerge;
case 3: return clang_ext_NoMerge_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nomerge_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoMerge_GNU_nomerge;
}
value
Val_clang_ext_nomerge_spelling(enum clang_ext_NoMerge_spelling v)
{
switch (v) {
case clang_ext_NoMerge_GNU_nomerge: return Val_int(0);
case clang_ext_NoMerge_CXX11_clang_nomerge: return Val_int(1);
case clang_ext_NoMerge_C2x_clang_nomerge: return Val_int(2);
case clang_ext_NoMerge_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nomerge_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoMerge_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoMerge_spelling result = clang_ext_NoMerge_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nomerge_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoMicroMips_spelling
Clang_ext_nomicromips_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoMicroMips_GNU_nomicromips;
case 1: return clang_ext_NoMicroMips_CXX11_gnu_nomicromips;
case 2: return clang_ext_NoMicroMips_C2x_gnu_nomicromips;
case 3: return clang_ext_NoMicroMips_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nomicromips_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoMicroMips_GNU_nomicromips;
}
value
Val_clang_ext_nomicromips_spelling(enum clang_ext_NoMicroMips_spelling v)
{
switch (v) {
case clang_ext_NoMicroMips_GNU_nomicromips: return Val_int(0);
case clang_ext_NoMicroMips_CXX11_gnu_nomicromips: return Val_int(1);
case clang_ext_NoMicroMips_C2x_gnu_nomicromips: return Val_int(2);
case clang_ext_NoMicroMips_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nomicromips_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoMicroMips_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoMicroMips_spelling result = clang_ext_NoMicroMips_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nomicromips_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoMips16_spelling
Clang_ext_nomips16_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoMips16_GNU_nomips16;
case 1: return clang_ext_NoMips16_CXX11_gnu_nomips16;
case 2: return clang_ext_NoMips16_C2x_gnu_nomips16;
case 3: return clang_ext_NoMips16_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nomips16_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoMips16_GNU_nomips16;
}
value
Val_clang_ext_nomips16_spelling(enum clang_ext_NoMips16_spelling v)
{
switch (v) {
case clang_ext_NoMips16_GNU_nomips16: return Val_int(0);
case clang_ext_NoMips16_CXX11_gnu_nomips16: return Val_int(1);
case clang_ext_NoMips16_C2x_gnu_nomips16: return Val_int(2);
case clang_ext_NoMips16_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nomips16_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoMips16_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoMips16_spelling result = clang_ext_NoMips16_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nomips16_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoProfileFunction_spelling
Clang_ext_noprofilefunction_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoProfileFunction_GNU_no_profile_instrument_function;
case 1: return clang_ext_NoProfileFunction_CXX11_gnu_no_profile_instrument_function;
case 2: return clang_ext_NoProfileFunction_C2x_gnu_no_profile_instrument_function;
case 3: return clang_ext_NoProfileFunction_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_noprofilefunction_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoProfileFunction_GNU_no_profile_instrument_function;
}
value
Val_clang_ext_noprofilefunction_spelling(enum clang_ext_NoProfileFunction_spelling v)
{
switch (v) {
case clang_ext_NoProfileFunction_GNU_no_profile_instrument_function: return Val_int(0);
case clang_ext_NoProfileFunction_CXX11_gnu_no_profile_instrument_function: return Val_int(1);
case clang_ext_NoProfileFunction_C2x_gnu_no_profile_instrument_function: return Val_int(2);
case clang_ext_NoProfileFunction_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_noprofilefunction_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoProfileFunction_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoProfileFunction_spelling result = clang_ext_NoProfileFunction_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_noprofilefunction_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoRandomizeLayout_spelling
Clang_ext_norandomizelayout_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoRandomizeLayout_GNU_no_randomize_layout;
case 1: return clang_ext_NoRandomizeLayout_CXX11_gnu_no_randomize_layout;
case 2: return clang_ext_NoRandomizeLayout_C2x_gnu_no_randomize_layout;
case 3: return clang_ext_NoRandomizeLayout_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_norandomizelayout_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoRandomizeLayout_GNU_no_randomize_layout;
}
value
Val_clang_ext_norandomizelayout_spelling(enum clang_ext_NoRandomizeLayout_spelling v)
{
switch (v) {
case clang_ext_NoRandomizeLayout_GNU_no_randomize_layout: return Val_int(0);
case clang_ext_NoRandomizeLayout_CXX11_gnu_no_randomize_layout: return Val_int(1);
case clang_ext_NoRandomizeLayout_C2x_gnu_no_randomize_layout: return Val_int(2);
case clang_ext_NoRandomizeLayout_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_norandomizelayout_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoRandomizeLayout_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoRandomizeLayout_spelling result = clang_ext_NoRandomizeLayout_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_norandomizelayout_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoReturn_spelling
Clang_ext_noreturn_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoReturn_GNU_noreturn;
case 1: return clang_ext_NoReturn_CXX11_gnu_noreturn;
case 2: return clang_ext_NoReturn_C2x_gnu_noreturn;
case 3: return clang_ext_NoReturn_Declspec_noreturn;
case 4: return clang_ext_NoReturn_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_noreturn_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoReturn_GNU_noreturn;
}
value
Val_clang_ext_noreturn_spelling(enum clang_ext_NoReturn_spelling v)
{
switch (v) {
case clang_ext_NoReturn_GNU_noreturn: return Val_int(0);
case clang_ext_NoReturn_CXX11_gnu_noreturn: return Val_int(1);
case clang_ext_NoReturn_C2x_gnu_noreturn: return Val_int(2);
case clang_ext_NoReturn_Declspec_noreturn: return Val_int(3);
case clang_ext_NoReturn_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_noreturn_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoReturn_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoReturn_spelling result = clang_ext_NoReturn_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_noreturn_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoSanitize_spelling
Clang_ext_nosanitize_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoSanitize_GNU_no_sanitize;
case 1: return clang_ext_NoSanitize_CXX11_clang_no_sanitize;
case 2: return clang_ext_NoSanitize_C2x_clang_no_sanitize;
case 3: return clang_ext_NoSanitize_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nosanitize_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoSanitize_GNU_no_sanitize;
}
value
Val_clang_ext_nosanitize_spelling(enum clang_ext_NoSanitize_spelling v)
{
switch (v) {
case clang_ext_NoSanitize_GNU_no_sanitize: return Val_int(0);
case clang_ext_NoSanitize_CXX11_clang_no_sanitize: return Val_int(1);
case clang_ext_NoSanitize_C2x_clang_no_sanitize: return Val_int(2);
case clang_ext_NoSanitize_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nosanitize_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoSanitize_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoSanitize_spelling result = clang_ext_NoSanitize_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nosanitize_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoSpeculativeLoadHardening_spelling
Clang_ext_nospeculativeloadhardening_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoSpeculativeLoadHardening_GNU_no_speculative_load_hardening;
case 1: return clang_ext_NoSpeculativeLoadHardening_CXX11_clang_no_speculative_load_hardening;
case 2: return clang_ext_NoSpeculativeLoadHardening_C2x_clang_no_speculative_load_hardening;
case 3: return clang_ext_NoSpeculativeLoadHardening_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nospeculativeloadhardening_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoSpeculativeLoadHardening_GNU_no_speculative_load_hardening;
}
value
Val_clang_ext_nospeculativeloadhardening_spelling(enum clang_ext_NoSpeculativeLoadHardening_spelling v)
{
switch (v) {
case clang_ext_NoSpeculativeLoadHardening_GNU_no_speculative_load_hardening: return Val_int(0);
case clang_ext_NoSpeculativeLoadHardening_CXX11_clang_no_speculative_load_hardening: return Val_int(1);
case clang_ext_NoSpeculativeLoadHardening_C2x_clang_no_speculative_load_hardening: return Val_int(2);
case clang_ext_NoSpeculativeLoadHardening_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nospeculativeloadhardening_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoSpeculativeLoadHardening_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoSpeculativeLoadHardening_spelling result = clang_ext_NoSpeculativeLoadHardening_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nospeculativeloadhardening_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoSplitStack_spelling
Clang_ext_nosplitstack_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoSplitStack_GNU_no_split_stack;
case 1: return clang_ext_NoSplitStack_CXX11_gnu_no_split_stack;
case 2: return clang_ext_NoSplitStack_C2x_gnu_no_split_stack;
case 3: return clang_ext_NoSplitStack_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nosplitstack_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoSplitStack_GNU_no_split_stack;
}
value
Val_clang_ext_nosplitstack_spelling(enum clang_ext_NoSplitStack_spelling v)
{
switch (v) {
case clang_ext_NoSplitStack_GNU_no_split_stack: return Val_int(0);
case clang_ext_NoSplitStack_CXX11_gnu_no_split_stack: return Val_int(1);
case clang_ext_NoSplitStack_C2x_gnu_no_split_stack: return Val_int(2);
case clang_ext_NoSplitStack_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nosplitstack_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoSplitStack_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoSplitStack_spelling result = clang_ext_NoSplitStack_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nosplitstack_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoStackProtector_spelling
Clang_ext_nostackprotector_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoStackProtector_GNU_no_stack_protector;
case 1: return clang_ext_NoStackProtector_CXX11_clang_no_stack_protector;
case 2: return clang_ext_NoStackProtector_C2x_clang_no_stack_protector;
case 3: return clang_ext_NoStackProtector_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nostackprotector_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoStackProtector_GNU_no_stack_protector;
}
value
Val_clang_ext_nostackprotector_spelling(enum clang_ext_NoStackProtector_spelling v)
{
switch (v) {
case clang_ext_NoStackProtector_GNU_no_stack_protector: return Val_int(0);
case clang_ext_NoStackProtector_CXX11_clang_no_stack_protector: return Val_int(1);
case clang_ext_NoStackProtector_C2x_clang_no_stack_protector: return Val_int(2);
case clang_ext_NoStackProtector_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nostackprotector_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoStackProtector_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoStackProtector_spelling result = clang_ext_NoStackProtector_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nostackprotector_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoThreadSafetyAnalysis_spelling
Clang_ext_nothreadsafetyanalysis_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoThreadSafetyAnalysis_GNU_no_thread_safety_analysis;
case 1: return clang_ext_NoThreadSafetyAnalysis_CXX11_clang_no_thread_safety_analysis;
case 2: return clang_ext_NoThreadSafetyAnalysis_C2x_clang_no_thread_safety_analysis;
case 3: return clang_ext_NoThreadSafetyAnalysis_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nothreadsafetyanalysis_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoThreadSafetyAnalysis_GNU_no_thread_safety_analysis;
}
value
Val_clang_ext_nothreadsafetyanalysis_spelling(enum clang_ext_NoThreadSafetyAnalysis_spelling v)
{
switch (v) {
case clang_ext_NoThreadSafetyAnalysis_GNU_no_thread_safety_analysis: return Val_int(0);
case clang_ext_NoThreadSafetyAnalysis_CXX11_clang_no_thread_safety_analysis: return Val_int(1);
case clang_ext_NoThreadSafetyAnalysis_C2x_clang_no_thread_safety_analysis: return Val_int(2);
case clang_ext_NoThreadSafetyAnalysis_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nothreadsafetyanalysis_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoThreadSafetyAnalysis_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoThreadSafetyAnalysis_spelling result = clang_ext_NoThreadSafetyAnalysis_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nothreadsafetyanalysis_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NoThrow_spelling
Clang_ext_nothrow_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NoThrow_GNU_nothrow;
case 1: return clang_ext_NoThrow_CXX11_gnu_nothrow;
case 2: return clang_ext_NoThrow_C2x_gnu_nothrow;
case 3: return clang_ext_NoThrow_Declspec_nothrow;
case 4: return clang_ext_NoThrow_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nothrow_spelling_val: %d", Int_val(ocaml));
return clang_ext_NoThrow_GNU_nothrow;
}
value
Val_clang_ext_nothrow_spelling(enum clang_ext_NoThrow_spelling v)
{
switch (v) {
case clang_ext_NoThrow_GNU_nothrow: return Val_int(0);
case clang_ext_NoThrow_CXX11_gnu_nothrow: return Val_int(1);
case clang_ext_NoThrow_C2x_gnu_nothrow: return Val_int(2);
case clang_ext_NoThrow_Declspec_nothrow: return Val_int(3);
case clang_ext_NoThrow_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nothrow_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NoThrow_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NoThrow_spelling result = clang_ext_NoThrow_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nothrow_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NonNull_spelling
Clang_ext_nonnull_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NonNull_GNU_nonnull;
case 1: return clang_ext_NonNull_CXX11_gnu_nonnull;
case 2: return clang_ext_NonNull_C2x_gnu_nonnull;
case 3: return clang_ext_NonNull_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nonnull_spelling_val: %d", Int_val(ocaml));
return clang_ext_NonNull_GNU_nonnull;
}
value
Val_clang_ext_nonnull_spelling(enum clang_ext_NonNull_spelling v)
{
switch (v) {
case clang_ext_NonNull_GNU_nonnull: return Val_int(0);
case clang_ext_NonNull_CXX11_gnu_nonnull: return Val_int(1);
case clang_ext_NonNull_C2x_gnu_nonnull: return Val_int(2);
case clang_ext_NonNull_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nonnull_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NonNull_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NonNull_spelling result = clang_ext_NonNull_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nonnull_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_NotTailCalled_spelling
Clang_ext_nottailcalled_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_NotTailCalled_GNU_not_tail_called;
case 1: return clang_ext_NotTailCalled_CXX11_clang_not_tail_called;
case 2: return clang_ext_NotTailCalled_C2x_clang_not_tail_called;
case 3: return clang_ext_NotTailCalled_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_nottailcalled_spelling_val: %d", Int_val(ocaml));
return clang_ext_NotTailCalled_GNU_not_tail_called;
}
value
Val_clang_ext_nottailcalled_spelling(enum clang_ext_NotTailCalled_spelling v)
{
switch (v) {
case clang_ext_NotTailCalled_GNU_not_tail_called: return Val_int(0);
case clang_ext_NotTailCalled_CXX11_clang_not_tail_called: return Val_int(1);
case clang_ext_NotTailCalled_C2x_clang_not_tail_called: return Val_int(2);
case clang_ext_NotTailCalled_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_nottailcalled_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_NotTailCalled_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_NotTailCalled_spelling result = clang_ext_NotTailCalled_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_nottailcalled_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OSConsumed_spelling
Clang_ext_osconsumed_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OSConsumed_GNU_os_consumed;
case 1: return clang_ext_OSConsumed_CXX11_clang_os_consumed;
case 2: return clang_ext_OSConsumed_C2x_clang_os_consumed;
case 3: return clang_ext_OSConsumed_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_osconsumed_spelling_val: %d", Int_val(ocaml));
return clang_ext_OSConsumed_GNU_os_consumed;
}
value
Val_clang_ext_osconsumed_spelling(enum clang_ext_OSConsumed_spelling v)
{
switch (v) {
case clang_ext_OSConsumed_GNU_os_consumed: return Val_int(0);
case clang_ext_OSConsumed_CXX11_clang_os_consumed: return Val_int(1);
case clang_ext_OSConsumed_C2x_clang_os_consumed: return Val_int(2);
case clang_ext_OSConsumed_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_osconsumed_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OSConsumed_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OSConsumed_spelling result = clang_ext_OSConsumed_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_osconsumed_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OSConsumesThis_spelling
Clang_ext_osconsumesthis_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OSConsumesThis_GNU_os_consumes_this;
case 1: return clang_ext_OSConsumesThis_CXX11_clang_os_consumes_this;
case 2: return clang_ext_OSConsumesThis_C2x_clang_os_consumes_this;
case 3: return clang_ext_OSConsumesThis_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_osconsumesthis_spelling_val: %d", Int_val(ocaml));
return clang_ext_OSConsumesThis_GNU_os_consumes_this;
}
value
Val_clang_ext_osconsumesthis_spelling(enum clang_ext_OSConsumesThis_spelling v)
{
switch (v) {
case clang_ext_OSConsumesThis_GNU_os_consumes_this: return Val_int(0);
case clang_ext_OSConsumesThis_CXX11_clang_os_consumes_this: return Val_int(1);
case clang_ext_OSConsumesThis_C2x_clang_os_consumes_this: return Val_int(2);
case clang_ext_OSConsumesThis_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_osconsumesthis_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OSConsumesThis_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OSConsumesThis_spelling result = clang_ext_OSConsumesThis_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_osconsumesthis_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OSReturnsNotRetained_spelling
Clang_ext_osreturnsnotretained_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OSReturnsNotRetained_GNU_os_returns_not_retained;
case 1: return clang_ext_OSReturnsNotRetained_CXX11_clang_os_returns_not_retained;
case 2: return clang_ext_OSReturnsNotRetained_C2x_clang_os_returns_not_retained;
case 3: return clang_ext_OSReturnsNotRetained_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_osreturnsnotretained_spelling_val: %d", Int_val(ocaml));
return clang_ext_OSReturnsNotRetained_GNU_os_returns_not_retained;
}
value
Val_clang_ext_osreturnsnotretained_spelling(enum clang_ext_OSReturnsNotRetained_spelling v)
{
switch (v) {
case clang_ext_OSReturnsNotRetained_GNU_os_returns_not_retained: return Val_int(0);
case clang_ext_OSReturnsNotRetained_CXX11_clang_os_returns_not_retained: return Val_int(1);
case clang_ext_OSReturnsNotRetained_C2x_clang_os_returns_not_retained: return Val_int(2);
case clang_ext_OSReturnsNotRetained_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_osreturnsnotretained_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OSReturnsNotRetained_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OSReturnsNotRetained_spelling result = clang_ext_OSReturnsNotRetained_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_osreturnsnotretained_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OSReturnsRetained_spelling
Clang_ext_osreturnsretained_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OSReturnsRetained_GNU_os_returns_retained;
case 1: return clang_ext_OSReturnsRetained_CXX11_clang_os_returns_retained;
case 2: return clang_ext_OSReturnsRetained_C2x_clang_os_returns_retained;
case 3: return clang_ext_OSReturnsRetained_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_osreturnsretained_spelling_val: %d", Int_val(ocaml));
return clang_ext_OSReturnsRetained_GNU_os_returns_retained;
}
value
Val_clang_ext_osreturnsretained_spelling(enum clang_ext_OSReturnsRetained_spelling v)
{
switch (v) {
case clang_ext_OSReturnsRetained_GNU_os_returns_retained: return Val_int(0);
case clang_ext_OSReturnsRetained_CXX11_clang_os_returns_retained: return Val_int(1);
case clang_ext_OSReturnsRetained_C2x_clang_os_returns_retained: return Val_int(2);
case clang_ext_OSReturnsRetained_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_osreturnsretained_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OSReturnsRetained_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OSReturnsRetained_spelling result = clang_ext_OSReturnsRetained_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_osreturnsretained_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OSReturnsRetainedOnNonZero_spelling
Clang_ext_osreturnsretainedonnonzero_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OSReturnsRetainedOnNonZero_GNU_os_returns_retained_on_non_zero;
case 1: return clang_ext_OSReturnsRetainedOnNonZero_CXX11_clang_os_returns_retained_on_non_zero;
case 2: return clang_ext_OSReturnsRetainedOnNonZero_C2x_clang_os_returns_retained_on_non_zero;
case 3: return clang_ext_OSReturnsRetainedOnNonZero_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_osreturnsretainedonnonzero_spelling_val: %d", Int_val(ocaml));
return clang_ext_OSReturnsRetainedOnNonZero_GNU_os_returns_retained_on_non_zero;
}
value
Val_clang_ext_osreturnsretainedonnonzero_spelling(enum clang_ext_OSReturnsRetainedOnNonZero_spelling v)
{
switch (v) {
case clang_ext_OSReturnsRetainedOnNonZero_GNU_os_returns_retained_on_non_zero: return Val_int(0);
case clang_ext_OSReturnsRetainedOnNonZero_CXX11_clang_os_returns_retained_on_non_zero: return Val_int(1);
case clang_ext_OSReturnsRetainedOnNonZero_C2x_clang_os_returns_retained_on_non_zero: return Val_int(2);
case clang_ext_OSReturnsRetainedOnNonZero_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_osreturnsretainedonnonzero_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OSReturnsRetainedOnNonZero_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OSReturnsRetainedOnNonZero_spelling result = clang_ext_OSReturnsRetainedOnNonZero_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_osreturnsretainedonnonzero_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OSReturnsRetainedOnZero_spelling
Clang_ext_osreturnsretainedonzero_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OSReturnsRetainedOnZero_GNU_os_returns_retained_on_zero;
case 1: return clang_ext_OSReturnsRetainedOnZero_CXX11_clang_os_returns_retained_on_zero;
case 2: return clang_ext_OSReturnsRetainedOnZero_C2x_clang_os_returns_retained_on_zero;
case 3: return clang_ext_OSReturnsRetainedOnZero_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_osreturnsretainedonzero_spelling_val: %d", Int_val(ocaml));
return clang_ext_OSReturnsRetainedOnZero_GNU_os_returns_retained_on_zero;
}
value
Val_clang_ext_osreturnsretainedonzero_spelling(enum clang_ext_OSReturnsRetainedOnZero_spelling v)
{
switch (v) {
case clang_ext_OSReturnsRetainedOnZero_GNU_os_returns_retained_on_zero: return Val_int(0);
case clang_ext_OSReturnsRetainedOnZero_CXX11_clang_os_returns_retained_on_zero: return Val_int(1);
case clang_ext_OSReturnsRetainedOnZero_C2x_clang_os_returns_retained_on_zero: return Val_int(2);
case clang_ext_OSReturnsRetainedOnZero_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_osreturnsretainedonzero_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OSReturnsRetainedOnZero_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OSReturnsRetainedOnZero_spelling result = clang_ext_OSReturnsRetainedOnZero_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_osreturnsretainedonzero_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCBoxable_spelling
Clang_ext_objcboxable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCBoxable_GNU_objc_boxable;
case 1: return clang_ext_ObjCBoxable_CXX11_clang_objc_boxable;
case 2: return clang_ext_ObjCBoxable_C2x_clang_objc_boxable;
case 3: return clang_ext_ObjCBoxable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcboxable_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCBoxable_GNU_objc_boxable;
}
value
Val_clang_ext_objcboxable_spelling(enum clang_ext_ObjCBoxable_spelling v)
{
switch (v) {
case clang_ext_ObjCBoxable_GNU_objc_boxable: return Val_int(0);
case clang_ext_ObjCBoxable_CXX11_clang_objc_boxable: return Val_int(1);
case clang_ext_ObjCBoxable_C2x_clang_objc_boxable: return Val_int(2);
case clang_ext_ObjCBoxable_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcboxable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCBoxable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCBoxable_spelling result = clang_ext_ObjCBoxable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcboxable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCBridge_spelling
Clang_ext_objcbridge_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCBridge_GNU_objc_bridge;
case 1: return clang_ext_ObjCBridge_CXX11_clang_objc_bridge;
case 2: return clang_ext_ObjCBridge_C2x_clang_objc_bridge;
case 3: return clang_ext_ObjCBridge_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcbridge_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCBridge_GNU_objc_bridge;
}
value
Val_clang_ext_objcbridge_spelling(enum clang_ext_ObjCBridge_spelling v)
{
switch (v) {
case clang_ext_ObjCBridge_GNU_objc_bridge: return Val_int(0);
case clang_ext_ObjCBridge_CXX11_clang_objc_bridge: return Val_int(1);
case clang_ext_ObjCBridge_C2x_clang_objc_bridge: return Val_int(2);
case clang_ext_ObjCBridge_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcbridge_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCBridge_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCBridge_spelling result = clang_ext_ObjCBridge_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcbridge_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCBridgeMutable_spelling
Clang_ext_objcbridgemutable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCBridgeMutable_GNU_objc_bridge_mutable;
case 1: return clang_ext_ObjCBridgeMutable_CXX11_clang_objc_bridge_mutable;
case 2: return clang_ext_ObjCBridgeMutable_C2x_clang_objc_bridge_mutable;
case 3: return clang_ext_ObjCBridgeMutable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcbridgemutable_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCBridgeMutable_GNU_objc_bridge_mutable;
}
value
Val_clang_ext_objcbridgemutable_spelling(enum clang_ext_ObjCBridgeMutable_spelling v)
{
switch (v) {
case clang_ext_ObjCBridgeMutable_GNU_objc_bridge_mutable: return Val_int(0);
case clang_ext_ObjCBridgeMutable_CXX11_clang_objc_bridge_mutable: return Val_int(1);
case clang_ext_ObjCBridgeMutable_C2x_clang_objc_bridge_mutable: return Val_int(2);
case clang_ext_ObjCBridgeMutable_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcbridgemutable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCBridgeMutable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCBridgeMutable_spelling result = clang_ext_ObjCBridgeMutable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcbridgemutable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCBridgeRelated_spelling
Clang_ext_objcbridgerelated_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCBridgeRelated_GNU_objc_bridge_related;
case 1: return clang_ext_ObjCBridgeRelated_CXX11_clang_objc_bridge_related;
case 2: return clang_ext_ObjCBridgeRelated_C2x_clang_objc_bridge_related;
case 3: return clang_ext_ObjCBridgeRelated_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcbridgerelated_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCBridgeRelated_GNU_objc_bridge_related;
}
value
Val_clang_ext_objcbridgerelated_spelling(enum clang_ext_ObjCBridgeRelated_spelling v)
{
switch (v) {
case clang_ext_ObjCBridgeRelated_GNU_objc_bridge_related: return Val_int(0);
case clang_ext_ObjCBridgeRelated_CXX11_clang_objc_bridge_related: return Val_int(1);
case clang_ext_ObjCBridgeRelated_C2x_clang_objc_bridge_related: return Val_int(2);
case clang_ext_ObjCBridgeRelated_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcbridgerelated_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCBridgeRelated_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCBridgeRelated_spelling result = clang_ext_ObjCBridgeRelated_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcbridgerelated_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCClassStub_spelling
Clang_ext_objcclassstub_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCClassStub_GNU_objc_class_stub;
case 1: return clang_ext_ObjCClassStub_CXX11_clang_objc_class_stub;
case 2: return clang_ext_ObjCClassStub_C2x_clang_objc_class_stub;
case 3: return clang_ext_ObjCClassStub_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcclassstub_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCClassStub_GNU_objc_class_stub;
}
value
Val_clang_ext_objcclassstub_spelling(enum clang_ext_ObjCClassStub_spelling v)
{
switch (v) {
case clang_ext_ObjCClassStub_GNU_objc_class_stub: return Val_int(0);
case clang_ext_ObjCClassStub_CXX11_clang_objc_class_stub: return Val_int(1);
case clang_ext_ObjCClassStub_C2x_clang_objc_class_stub: return Val_int(2);
case clang_ext_ObjCClassStub_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcclassstub_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCClassStub_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCClassStub_spelling result = clang_ext_ObjCClassStub_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcclassstub_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCDesignatedInitializer_spelling
Clang_ext_objcdesignatedinitializer_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCDesignatedInitializer_GNU_objc_designated_initializer;
case 1: return clang_ext_ObjCDesignatedInitializer_CXX11_clang_objc_designated_initializer;
case 2: return clang_ext_ObjCDesignatedInitializer_C2x_clang_objc_designated_initializer;
case 3: return clang_ext_ObjCDesignatedInitializer_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcdesignatedinitializer_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCDesignatedInitializer_GNU_objc_designated_initializer;
}
value
Val_clang_ext_objcdesignatedinitializer_spelling(enum clang_ext_ObjCDesignatedInitializer_spelling v)
{
switch (v) {
case clang_ext_ObjCDesignatedInitializer_GNU_objc_designated_initializer: return Val_int(0);
case clang_ext_ObjCDesignatedInitializer_CXX11_clang_objc_designated_initializer: return Val_int(1);
case clang_ext_ObjCDesignatedInitializer_C2x_clang_objc_designated_initializer: return Val_int(2);
case clang_ext_ObjCDesignatedInitializer_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcdesignatedinitializer_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCDesignatedInitializer_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCDesignatedInitializer_spelling result = clang_ext_ObjCDesignatedInitializer_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcdesignatedinitializer_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCDirect_spelling
Clang_ext_objcdirect_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCDirect_GNU_objc_direct;
case 1: return clang_ext_ObjCDirect_CXX11_clang_objc_direct;
case 2: return clang_ext_ObjCDirect_C2x_clang_objc_direct;
case 3: return clang_ext_ObjCDirect_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcdirect_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCDirect_GNU_objc_direct;
}
value
Val_clang_ext_objcdirect_spelling(enum clang_ext_ObjCDirect_spelling v)
{
switch (v) {
case clang_ext_ObjCDirect_GNU_objc_direct: return Val_int(0);
case clang_ext_ObjCDirect_CXX11_clang_objc_direct: return Val_int(1);
case clang_ext_ObjCDirect_C2x_clang_objc_direct: return Val_int(2);
case clang_ext_ObjCDirect_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcdirect_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCDirect_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCDirect_spelling result = clang_ext_ObjCDirect_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcdirect_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCDirectMembers_spelling
Clang_ext_objcdirectmembers_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCDirectMembers_GNU_objc_direct_members;
case 1: return clang_ext_ObjCDirectMembers_CXX11_clang_objc_direct_members;
case 2: return clang_ext_ObjCDirectMembers_C2x_clang_objc_direct_members;
case 3: return clang_ext_ObjCDirectMembers_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcdirectmembers_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCDirectMembers_GNU_objc_direct_members;
}
value
Val_clang_ext_objcdirectmembers_spelling(enum clang_ext_ObjCDirectMembers_spelling v)
{
switch (v) {
case clang_ext_ObjCDirectMembers_GNU_objc_direct_members: return Val_int(0);
case clang_ext_ObjCDirectMembers_CXX11_clang_objc_direct_members: return Val_int(1);
case clang_ext_ObjCDirectMembers_C2x_clang_objc_direct_members: return Val_int(2);
case clang_ext_ObjCDirectMembers_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcdirectmembers_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCDirectMembers_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCDirectMembers_spelling result = clang_ext_ObjCDirectMembers_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcdirectmembers_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCException_spelling
Clang_ext_objcexception_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCException_GNU_objc_exception;
case 1: return clang_ext_ObjCException_CXX11_clang_objc_exception;
case 2: return clang_ext_ObjCException_C2x_clang_objc_exception;
case 3: return clang_ext_ObjCException_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcexception_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCException_GNU_objc_exception;
}
value
Val_clang_ext_objcexception_spelling(enum clang_ext_ObjCException_spelling v)
{
switch (v) {
case clang_ext_ObjCException_GNU_objc_exception: return Val_int(0);
case clang_ext_ObjCException_CXX11_clang_objc_exception: return Val_int(1);
case clang_ext_ObjCException_C2x_clang_objc_exception: return Val_int(2);
case clang_ext_ObjCException_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcexception_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCException_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCException_spelling result = clang_ext_ObjCException_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcexception_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCExplicitProtocolImpl_spelling
Clang_ext_objcexplicitprotocolimpl_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCExplicitProtocolImpl_GNU_objc_protocol_requires_explicit_implementation;
case 1: return clang_ext_ObjCExplicitProtocolImpl_CXX11_clang_objc_protocol_requires_explicit_implementation;
case 2: return clang_ext_ObjCExplicitProtocolImpl_C2x_clang_objc_protocol_requires_explicit_implementation;
case 3: return clang_ext_ObjCExplicitProtocolImpl_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcexplicitprotocolimpl_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCExplicitProtocolImpl_GNU_objc_protocol_requires_explicit_implementation;
}
value
Val_clang_ext_objcexplicitprotocolimpl_spelling(enum clang_ext_ObjCExplicitProtocolImpl_spelling v)
{
switch (v) {
case clang_ext_ObjCExplicitProtocolImpl_GNU_objc_protocol_requires_explicit_implementation: return Val_int(0);
case clang_ext_ObjCExplicitProtocolImpl_CXX11_clang_objc_protocol_requires_explicit_implementation: return Val_int(1);
case clang_ext_ObjCExplicitProtocolImpl_C2x_clang_objc_protocol_requires_explicit_implementation: return Val_int(2);
case clang_ext_ObjCExplicitProtocolImpl_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcexplicitprotocolimpl_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCExplicitProtocolImpl_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCExplicitProtocolImpl_spelling result = clang_ext_ObjCExplicitProtocolImpl_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcexplicitprotocolimpl_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCExternallyRetained_spelling
Clang_ext_objcexternallyretained_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCExternallyRetained_GNU_objc_externally_retained;
case 1: return clang_ext_ObjCExternallyRetained_CXX11_clang_objc_externally_retained;
case 2: return clang_ext_ObjCExternallyRetained_C2x_clang_objc_externally_retained;
case 3: return clang_ext_ObjCExternallyRetained_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcexternallyretained_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCExternallyRetained_GNU_objc_externally_retained;
}
value
Val_clang_ext_objcexternallyretained_spelling(enum clang_ext_ObjCExternallyRetained_spelling v)
{
switch (v) {
case clang_ext_ObjCExternallyRetained_GNU_objc_externally_retained: return Val_int(0);
case clang_ext_ObjCExternallyRetained_CXX11_clang_objc_externally_retained: return Val_int(1);
case clang_ext_ObjCExternallyRetained_C2x_clang_objc_externally_retained: return Val_int(2);
case clang_ext_ObjCExternallyRetained_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcexternallyretained_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCExternallyRetained_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCExternallyRetained_spelling result = clang_ext_ObjCExternallyRetained_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcexternallyretained_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCGC_spelling
Clang_ext_objcgc_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCGC_GNU_objc_gc;
case 1: return clang_ext_ObjCGC_CXX11_clang_objc_gc;
case 2: return clang_ext_ObjCGC_C2x_clang_objc_gc;
case 3: return clang_ext_ObjCGC_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcgc_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCGC_GNU_objc_gc;
}
value
Val_clang_ext_objcgc_spelling(enum clang_ext_ObjCGC_spelling v)
{
switch (v) {
case clang_ext_ObjCGC_GNU_objc_gc: return Val_int(0);
case clang_ext_ObjCGC_CXX11_clang_objc_gc: return Val_int(1);
case clang_ext_ObjCGC_C2x_clang_objc_gc: return Val_int(2);
case clang_ext_ObjCGC_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcgc_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCGC_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCGC_spelling result = clang_ext_ObjCGC_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcgc_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCIndependentClass_spelling
Clang_ext_objcindependentclass_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCIndependentClass_GNU_objc_independent_class;
case 1: return clang_ext_ObjCIndependentClass_CXX11_clang_objc_independent_class;
case 2: return clang_ext_ObjCIndependentClass_C2x_clang_objc_independent_class;
case 3: return clang_ext_ObjCIndependentClass_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcindependentclass_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCIndependentClass_GNU_objc_independent_class;
}
value
Val_clang_ext_objcindependentclass_spelling(enum clang_ext_ObjCIndependentClass_spelling v)
{
switch (v) {
case clang_ext_ObjCIndependentClass_GNU_objc_independent_class: return Val_int(0);
case clang_ext_ObjCIndependentClass_CXX11_clang_objc_independent_class: return Val_int(1);
case clang_ext_ObjCIndependentClass_C2x_clang_objc_independent_class: return Val_int(2);
case clang_ext_ObjCIndependentClass_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcindependentclass_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCIndependentClass_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCIndependentClass_spelling result = clang_ext_ObjCIndependentClass_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcindependentclass_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCMethodFamily_spelling
Clang_ext_objcmethodfamily_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCMethodFamily_GNU_objc_method_family;
case 1: return clang_ext_ObjCMethodFamily_CXX11_clang_objc_method_family;
case 2: return clang_ext_ObjCMethodFamily_C2x_clang_objc_method_family;
case 3: return clang_ext_ObjCMethodFamily_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcmethodfamily_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCMethodFamily_GNU_objc_method_family;
}
value
Val_clang_ext_objcmethodfamily_spelling(enum clang_ext_ObjCMethodFamily_spelling v)
{
switch (v) {
case clang_ext_ObjCMethodFamily_GNU_objc_method_family: return Val_int(0);
case clang_ext_ObjCMethodFamily_CXX11_clang_objc_method_family: return Val_int(1);
case clang_ext_ObjCMethodFamily_C2x_clang_objc_method_family: return Val_int(2);
case clang_ext_ObjCMethodFamily_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcmethodfamily_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCMethodFamily_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCMethodFamily_spelling result = clang_ext_ObjCMethodFamily_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcmethodfamily_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCNSObject_spelling
Clang_ext_objcnsobject_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCNSObject_GNU_NSObject;
case 1: return clang_ext_ObjCNSObject_CXX11_clang_NSObject;
case 2: return clang_ext_ObjCNSObject_C2x_clang_NSObject;
case 3: return clang_ext_ObjCNSObject_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcnsobject_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCNSObject_GNU_NSObject;
}
value
Val_clang_ext_objcnsobject_spelling(enum clang_ext_ObjCNSObject_spelling v)
{
switch (v) {
case clang_ext_ObjCNSObject_GNU_NSObject: return Val_int(0);
case clang_ext_ObjCNSObject_CXX11_clang_NSObject: return Val_int(1);
case clang_ext_ObjCNSObject_C2x_clang_NSObject: return Val_int(2);
case clang_ext_ObjCNSObject_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcnsobject_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCNSObject_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCNSObject_spelling result = clang_ext_ObjCNSObject_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcnsobject_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCNonLazyClass_spelling
Clang_ext_objcnonlazyclass_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCNonLazyClass_GNU_objc_nonlazy_class;
case 1: return clang_ext_ObjCNonLazyClass_CXX11_clang_objc_nonlazy_class;
case 2: return clang_ext_ObjCNonLazyClass_C2x_clang_objc_nonlazy_class;
case 3: return clang_ext_ObjCNonLazyClass_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcnonlazyclass_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCNonLazyClass_GNU_objc_nonlazy_class;
}
value
Val_clang_ext_objcnonlazyclass_spelling(enum clang_ext_ObjCNonLazyClass_spelling v)
{
switch (v) {
case clang_ext_ObjCNonLazyClass_GNU_objc_nonlazy_class: return Val_int(0);
case clang_ext_ObjCNonLazyClass_CXX11_clang_objc_nonlazy_class: return Val_int(1);
case clang_ext_ObjCNonLazyClass_C2x_clang_objc_nonlazy_class: return Val_int(2);
case clang_ext_ObjCNonLazyClass_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcnonlazyclass_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCNonLazyClass_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCNonLazyClass_spelling result = clang_ext_ObjCNonLazyClass_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcnonlazyclass_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCNonRuntimeProtocol_spelling
Clang_ext_objcnonruntimeprotocol_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCNonRuntimeProtocol_GNU_objc_non_runtime_protocol;
case 1: return clang_ext_ObjCNonRuntimeProtocol_CXX11_clang_objc_non_runtime_protocol;
case 2: return clang_ext_ObjCNonRuntimeProtocol_C2x_clang_objc_non_runtime_protocol;
case 3: return clang_ext_ObjCNonRuntimeProtocol_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcnonruntimeprotocol_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCNonRuntimeProtocol_GNU_objc_non_runtime_protocol;
}
value
Val_clang_ext_objcnonruntimeprotocol_spelling(enum clang_ext_ObjCNonRuntimeProtocol_spelling v)
{
switch (v) {
case clang_ext_ObjCNonRuntimeProtocol_GNU_objc_non_runtime_protocol: return Val_int(0);
case clang_ext_ObjCNonRuntimeProtocol_CXX11_clang_objc_non_runtime_protocol: return Val_int(1);
case clang_ext_ObjCNonRuntimeProtocol_C2x_clang_objc_non_runtime_protocol: return Val_int(2);
case clang_ext_ObjCNonRuntimeProtocol_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcnonruntimeprotocol_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCNonRuntimeProtocol_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCNonRuntimeProtocol_spelling result = clang_ext_ObjCNonRuntimeProtocol_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcnonruntimeprotocol_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCOwnership_spelling
Clang_ext_objcownership_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCOwnership_GNU_objc_ownership;
case 1: return clang_ext_ObjCOwnership_CXX11_clang_objc_ownership;
case 2: return clang_ext_ObjCOwnership_C2x_clang_objc_ownership;
case 3: return clang_ext_ObjCOwnership_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcownership_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCOwnership_GNU_objc_ownership;
}
value
Val_clang_ext_objcownership_spelling(enum clang_ext_ObjCOwnership_spelling v)
{
switch (v) {
case clang_ext_ObjCOwnership_GNU_objc_ownership: return Val_int(0);
case clang_ext_ObjCOwnership_CXX11_clang_objc_ownership: return Val_int(1);
case clang_ext_ObjCOwnership_C2x_clang_objc_ownership: return Val_int(2);
case clang_ext_ObjCOwnership_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcownership_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCOwnership_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCOwnership_spelling result = clang_ext_ObjCOwnership_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcownership_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCPreciseLifetime_spelling
Clang_ext_objcpreciselifetime_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCPreciseLifetime_GNU_objc_precise_lifetime;
case 1: return clang_ext_ObjCPreciseLifetime_CXX11_clang_objc_precise_lifetime;
case 2: return clang_ext_ObjCPreciseLifetime_C2x_clang_objc_precise_lifetime;
case 3: return clang_ext_ObjCPreciseLifetime_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcpreciselifetime_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCPreciseLifetime_GNU_objc_precise_lifetime;
}
value
Val_clang_ext_objcpreciselifetime_spelling(enum clang_ext_ObjCPreciseLifetime_spelling v)
{
switch (v) {
case clang_ext_ObjCPreciseLifetime_GNU_objc_precise_lifetime: return Val_int(0);
case clang_ext_ObjCPreciseLifetime_CXX11_clang_objc_precise_lifetime: return Val_int(1);
case clang_ext_ObjCPreciseLifetime_C2x_clang_objc_precise_lifetime: return Val_int(2);
case clang_ext_ObjCPreciseLifetime_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcpreciselifetime_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCPreciseLifetime_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCPreciseLifetime_spelling result = clang_ext_ObjCPreciseLifetime_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcpreciselifetime_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCRequiresPropertyDefs_spelling
Clang_ext_objcrequirespropertydefs_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCRequiresPropertyDefs_GNU_objc_requires_property_definitions;
case 1: return clang_ext_ObjCRequiresPropertyDefs_CXX11_clang_objc_requires_property_definitions;
case 2: return clang_ext_ObjCRequiresPropertyDefs_C2x_clang_objc_requires_property_definitions;
case 3: return clang_ext_ObjCRequiresPropertyDefs_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcrequirespropertydefs_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCRequiresPropertyDefs_GNU_objc_requires_property_definitions;
}
value
Val_clang_ext_objcrequirespropertydefs_spelling(enum clang_ext_ObjCRequiresPropertyDefs_spelling v)
{
switch (v) {
case clang_ext_ObjCRequiresPropertyDefs_GNU_objc_requires_property_definitions: return Val_int(0);
case clang_ext_ObjCRequiresPropertyDefs_CXX11_clang_objc_requires_property_definitions: return Val_int(1);
case clang_ext_ObjCRequiresPropertyDefs_C2x_clang_objc_requires_property_definitions: return Val_int(2);
case clang_ext_ObjCRequiresPropertyDefs_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcrequirespropertydefs_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCRequiresPropertyDefs_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCRequiresPropertyDefs_spelling result = clang_ext_ObjCRequiresPropertyDefs_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcrequirespropertydefs_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCRequiresSuper_spelling
Clang_ext_objcrequiressuper_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCRequiresSuper_GNU_objc_requires_super;
case 1: return clang_ext_ObjCRequiresSuper_CXX11_clang_objc_requires_super;
case 2: return clang_ext_ObjCRequiresSuper_C2x_clang_objc_requires_super;
case 3: return clang_ext_ObjCRequiresSuper_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcrequiressuper_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCRequiresSuper_GNU_objc_requires_super;
}
value
Val_clang_ext_objcrequiressuper_spelling(enum clang_ext_ObjCRequiresSuper_spelling v)
{
switch (v) {
case clang_ext_ObjCRequiresSuper_GNU_objc_requires_super: return Val_int(0);
case clang_ext_ObjCRequiresSuper_CXX11_clang_objc_requires_super: return Val_int(1);
case clang_ext_ObjCRequiresSuper_C2x_clang_objc_requires_super: return Val_int(2);
case clang_ext_ObjCRequiresSuper_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcrequiressuper_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCRequiresSuper_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCRequiresSuper_spelling result = clang_ext_ObjCRequiresSuper_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcrequiressuper_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCReturnsInnerPointer_spelling
Clang_ext_objcreturnsinnerpointer_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCReturnsInnerPointer_GNU_objc_returns_inner_pointer;
case 1: return clang_ext_ObjCReturnsInnerPointer_CXX11_clang_objc_returns_inner_pointer;
case 2: return clang_ext_ObjCReturnsInnerPointer_C2x_clang_objc_returns_inner_pointer;
case 3: return clang_ext_ObjCReturnsInnerPointer_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcreturnsinnerpointer_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCReturnsInnerPointer_GNU_objc_returns_inner_pointer;
}
value
Val_clang_ext_objcreturnsinnerpointer_spelling(enum clang_ext_ObjCReturnsInnerPointer_spelling v)
{
switch (v) {
case clang_ext_ObjCReturnsInnerPointer_GNU_objc_returns_inner_pointer: return Val_int(0);
case clang_ext_ObjCReturnsInnerPointer_CXX11_clang_objc_returns_inner_pointer: return Val_int(1);
case clang_ext_ObjCReturnsInnerPointer_C2x_clang_objc_returns_inner_pointer: return Val_int(2);
case clang_ext_ObjCReturnsInnerPointer_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcreturnsinnerpointer_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCReturnsInnerPointer_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCReturnsInnerPointer_spelling result = clang_ext_ObjCReturnsInnerPointer_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcreturnsinnerpointer_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCRootClass_spelling
Clang_ext_objcrootclass_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCRootClass_GNU_objc_root_class;
case 1: return clang_ext_ObjCRootClass_CXX11_clang_objc_root_class;
case 2: return clang_ext_ObjCRootClass_C2x_clang_objc_root_class;
case 3: return clang_ext_ObjCRootClass_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcrootclass_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCRootClass_GNU_objc_root_class;
}
value
Val_clang_ext_objcrootclass_spelling(enum clang_ext_ObjCRootClass_spelling v)
{
switch (v) {
case clang_ext_ObjCRootClass_GNU_objc_root_class: return Val_int(0);
case clang_ext_ObjCRootClass_CXX11_clang_objc_root_class: return Val_int(1);
case clang_ext_ObjCRootClass_C2x_clang_objc_root_class: return Val_int(2);
case clang_ext_ObjCRootClass_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcrootclass_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCRootClass_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCRootClass_spelling result = clang_ext_ObjCRootClass_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcrootclass_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCRuntimeName_spelling
Clang_ext_objcruntimename_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCRuntimeName_GNU_objc_runtime_name;
case 1: return clang_ext_ObjCRuntimeName_CXX11_clang_objc_runtime_name;
case 2: return clang_ext_ObjCRuntimeName_C2x_clang_objc_runtime_name;
case 3: return clang_ext_ObjCRuntimeName_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcruntimename_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCRuntimeName_GNU_objc_runtime_name;
}
value
Val_clang_ext_objcruntimename_spelling(enum clang_ext_ObjCRuntimeName_spelling v)
{
switch (v) {
case clang_ext_ObjCRuntimeName_GNU_objc_runtime_name: return Val_int(0);
case clang_ext_ObjCRuntimeName_CXX11_clang_objc_runtime_name: return Val_int(1);
case clang_ext_ObjCRuntimeName_C2x_clang_objc_runtime_name: return Val_int(2);
case clang_ext_ObjCRuntimeName_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcruntimename_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCRuntimeName_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCRuntimeName_spelling result = clang_ext_ObjCRuntimeName_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcruntimename_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCRuntimeVisible_spelling
Clang_ext_objcruntimevisible_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCRuntimeVisible_GNU_objc_runtime_visible;
case 1: return clang_ext_ObjCRuntimeVisible_CXX11_clang_objc_runtime_visible;
case 2: return clang_ext_ObjCRuntimeVisible_C2x_clang_objc_runtime_visible;
case 3: return clang_ext_ObjCRuntimeVisible_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcruntimevisible_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCRuntimeVisible_GNU_objc_runtime_visible;
}
value
Val_clang_ext_objcruntimevisible_spelling(enum clang_ext_ObjCRuntimeVisible_spelling v)
{
switch (v) {
case clang_ext_ObjCRuntimeVisible_GNU_objc_runtime_visible: return Val_int(0);
case clang_ext_ObjCRuntimeVisible_CXX11_clang_objc_runtime_visible: return Val_int(1);
case clang_ext_ObjCRuntimeVisible_C2x_clang_objc_runtime_visible: return Val_int(2);
case clang_ext_ObjCRuntimeVisible_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcruntimevisible_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCRuntimeVisible_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCRuntimeVisible_spelling result = clang_ext_ObjCRuntimeVisible_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcruntimevisible_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ObjCSubclassingRestricted_spelling
Clang_ext_objcsubclassingrestricted_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCSubclassingRestricted_GNU_objc_subclassing_restricted;
case 1: return clang_ext_ObjCSubclassingRestricted_CXX11_clang_objc_subclassing_restricted;
case 2: return clang_ext_ObjCSubclassingRestricted_C2x_clang_objc_subclassing_restricted;
case 3: return clang_ext_ObjCSubclassingRestricted_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_objcsubclassingrestricted_spelling_val: %d", Int_val(ocaml));
return clang_ext_ObjCSubclassingRestricted_GNU_objc_subclassing_restricted;
}
value
Val_clang_ext_objcsubclassingrestricted_spelling(enum clang_ext_ObjCSubclassingRestricted_spelling v)
{
switch (v) {
case clang_ext_ObjCSubclassingRestricted_GNU_objc_subclassing_restricted: return Val_int(0);
case clang_ext_ObjCSubclassingRestricted_CXX11_clang_objc_subclassing_restricted: return Val_int(1);
case clang_ext_ObjCSubclassingRestricted_C2x_clang_objc_subclassing_restricted: return Val_int(2);
case clang_ext_ObjCSubclassingRestricted_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcsubclassingrestricted_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCSubclassingRestricted_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCSubclassingRestricted_spelling result = clang_ext_ObjCSubclassingRestricted_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcsubclassingrestricted_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLAccess_spelling
Clang_ext_openclaccess_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLAccess_Keyword_read_only;
case 1: return clang_ext_OpenCLAccess_Keyword_write_only;
case 2: return clang_ext_OpenCLAccess_Keyword_read_write;
case 3: return clang_ext_OpenCLAccess_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclaccess_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLAccess_Keyword_read_only;
}
value
Val_clang_ext_openclaccess_spelling(enum clang_ext_OpenCLAccess_spelling v)
{
switch (v) {
case clang_ext_OpenCLAccess_Keyword_read_only: return Val_int(0);
case clang_ext_OpenCLAccess_Keyword_write_only: return Val_int(1);
case clang_ext_OpenCLAccess_Keyword_read_write: return Val_int(2);
case clang_ext_OpenCLAccess_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclaccess_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLAccess_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLAccess_spelling result = clang_ext_OpenCLAccess_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclaccess_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLConstantAddressSpace_spelling
Clang_ext_openclconstantaddressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLConstantAddressSpace_Keyword_constant;
case 1: return clang_ext_OpenCLConstantAddressSpace_GNU_opencl_constant;
case 2: return clang_ext_OpenCLConstantAddressSpace_CXX11_clang_opencl_constant;
case 3: return clang_ext_OpenCLConstantAddressSpace_C2x_clang_opencl_constant;
case 4: return clang_ext_OpenCLConstantAddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclconstantaddressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLConstantAddressSpace_Keyword_constant;
}
value
Val_clang_ext_openclconstantaddressspace_spelling(enum clang_ext_OpenCLConstantAddressSpace_spelling v)
{
switch (v) {
case clang_ext_OpenCLConstantAddressSpace_Keyword_constant: return Val_int(0);
case clang_ext_OpenCLConstantAddressSpace_GNU_opencl_constant: return Val_int(1);
case clang_ext_OpenCLConstantAddressSpace_CXX11_clang_opencl_constant: return Val_int(2);
case clang_ext_OpenCLConstantAddressSpace_C2x_clang_opencl_constant: return Val_int(3);
case clang_ext_OpenCLConstantAddressSpace_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclconstantaddressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLConstantAddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLConstantAddressSpace_spelling result = clang_ext_OpenCLConstantAddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclconstantaddressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLGenericAddressSpace_spelling
Clang_ext_openclgenericaddressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLGenericAddressSpace_Keyword_generic;
case 1: return clang_ext_OpenCLGenericAddressSpace_GNU_opencl_generic;
case 2: return clang_ext_OpenCLGenericAddressSpace_CXX11_clang_opencl_generic;
case 3: return clang_ext_OpenCLGenericAddressSpace_C2x_clang_opencl_generic;
case 4: return clang_ext_OpenCLGenericAddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclgenericaddressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLGenericAddressSpace_Keyword_generic;
}
value
Val_clang_ext_openclgenericaddressspace_spelling(enum clang_ext_OpenCLGenericAddressSpace_spelling v)
{
switch (v) {
case clang_ext_OpenCLGenericAddressSpace_Keyword_generic: return Val_int(0);
case clang_ext_OpenCLGenericAddressSpace_GNU_opencl_generic: return Val_int(1);
case clang_ext_OpenCLGenericAddressSpace_CXX11_clang_opencl_generic: return Val_int(2);
case clang_ext_OpenCLGenericAddressSpace_C2x_clang_opencl_generic: return Val_int(3);
case clang_ext_OpenCLGenericAddressSpace_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclgenericaddressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLGenericAddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLGenericAddressSpace_spelling result = clang_ext_OpenCLGenericAddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclgenericaddressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLGlobalAddressSpace_spelling
Clang_ext_openclglobaladdressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLGlobalAddressSpace_Keyword_global;
case 1: return clang_ext_OpenCLGlobalAddressSpace_GNU_opencl_global;
case 2: return clang_ext_OpenCLGlobalAddressSpace_CXX11_clang_opencl_global;
case 3: return clang_ext_OpenCLGlobalAddressSpace_C2x_clang_opencl_global;
case 4: return clang_ext_OpenCLGlobalAddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclglobaladdressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLGlobalAddressSpace_Keyword_global;
}
value
Val_clang_ext_openclglobaladdressspace_spelling(enum clang_ext_OpenCLGlobalAddressSpace_spelling v)
{
switch (v) {
case clang_ext_OpenCLGlobalAddressSpace_Keyword_global: return Val_int(0);
case clang_ext_OpenCLGlobalAddressSpace_GNU_opencl_global: return Val_int(1);
case clang_ext_OpenCLGlobalAddressSpace_CXX11_clang_opencl_global: return Val_int(2);
case clang_ext_OpenCLGlobalAddressSpace_C2x_clang_opencl_global: return Val_int(3);
case clang_ext_OpenCLGlobalAddressSpace_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclglobaladdressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLGlobalAddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLGlobalAddressSpace_spelling result = clang_ext_OpenCLGlobalAddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclglobaladdressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLGlobalDeviceAddressSpace_spelling
Clang_ext_openclglobaldeviceaddressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLGlobalDeviceAddressSpace_GNU_opencl_global_device;
case 1: return clang_ext_OpenCLGlobalDeviceAddressSpace_CXX11_clang_opencl_global_device;
case 2: return clang_ext_OpenCLGlobalDeviceAddressSpace_C2x_clang_opencl_global_device;
case 3: return clang_ext_OpenCLGlobalDeviceAddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclglobaldeviceaddressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLGlobalDeviceAddressSpace_GNU_opencl_global_device;
}
value
Val_clang_ext_openclglobaldeviceaddressspace_spelling(enum clang_ext_OpenCLGlobalDeviceAddressSpace_spelling v)
{
switch (v) {
case clang_ext_OpenCLGlobalDeviceAddressSpace_GNU_opencl_global_device: return Val_int(0);
case clang_ext_OpenCLGlobalDeviceAddressSpace_CXX11_clang_opencl_global_device: return Val_int(1);
case clang_ext_OpenCLGlobalDeviceAddressSpace_C2x_clang_opencl_global_device: return Val_int(2);
case clang_ext_OpenCLGlobalDeviceAddressSpace_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclglobaldeviceaddressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLGlobalDeviceAddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLGlobalDeviceAddressSpace_spelling result = clang_ext_OpenCLGlobalDeviceAddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclglobaldeviceaddressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLGlobalHostAddressSpace_spelling
Clang_ext_openclglobalhostaddressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLGlobalHostAddressSpace_GNU_opencl_global_host;
case 1: return clang_ext_OpenCLGlobalHostAddressSpace_CXX11_clang_opencl_global_host;
case 2: return clang_ext_OpenCLGlobalHostAddressSpace_C2x_clang_opencl_global_host;
case 3: return clang_ext_OpenCLGlobalHostAddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclglobalhostaddressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLGlobalHostAddressSpace_GNU_opencl_global_host;
}
value
Val_clang_ext_openclglobalhostaddressspace_spelling(enum clang_ext_OpenCLGlobalHostAddressSpace_spelling v)
{
switch (v) {
case clang_ext_OpenCLGlobalHostAddressSpace_GNU_opencl_global_host: return Val_int(0);
case clang_ext_OpenCLGlobalHostAddressSpace_CXX11_clang_opencl_global_host: return Val_int(1);
case clang_ext_OpenCLGlobalHostAddressSpace_C2x_clang_opencl_global_host: return Val_int(2);
case clang_ext_OpenCLGlobalHostAddressSpace_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclglobalhostaddressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLGlobalHostAddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLGlobalHostAddressSpace_spelling result = clang_ext_OpenCLGlobalHostAddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclglobalhostaddressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLKernel_spelling
Clang_ext_openclkernel_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLKernel_Keyword_kernel;
case 1: return clang_ext_OpenCLKernel_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclkernel_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLKernel_Keyword_kernel;
}
value
Val_clang_ext_openclkernel_spelling(enum clang_ext_OpenCLKernel_spelling v)
{
switch (v) {
case clang_ext_OpenCLKernel_Keyword_kernel: return Val_int(0);
case clang_ext_OpenCLKernel_SpellingNotCalculated: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclkernel_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLKernel_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLKernel_spelling result = clang_ext_OpenCLKernel_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclkernel_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLLocalAddressSpace_spelling
Clang_ext_opencllocaladdressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLLocalAddressSpace_Keyword_local;
case 1: return clang_ext_OpenCLLocalAddressSpace_GNU_opencl_local;
case 2: return clang_ext_OpenCLLocalAddressSpace_CXX11_clang_opencl_local;
case 3: return clang_ext_OpenCLLocalAddressSpace_C2x_clang_opencl_local;
case 4: return clang_ext_OpenCLLocalAddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_opencllocaladdressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLLocalAddressSpace_Keyword_local;
}
value
Val_clang_ext_opencllocaladdressspace_spelling(enum clang_ext_OpenCLLocalAddressSpace_spelling v)
{
switch (v) {
case clang_ext_OpenCLLocalAddressSpace_Keyword_local: return Val_int(0);
case clang_ext_OpenCLLocalAddressSpace_GNU_opencl_local: return Val_int(1);
case clang_ext_OpenCLLocalAddressSpace_CXX11_clang_opencl_local: return Val_int(2);
case clang_ext_OpenCLLocalAddressSpace_C2x_clang_opencl_local: return Val_int(3);
case clang_ext_OpenCLLocalAddressSpace_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_opencllocaladdressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLLocalAddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLLocalAddressSpace_spelling result = clang_ext_OpenCLLocalAddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_opencllocaladdressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OpenCLPrivateAddressSpace_spelling
Clang_ext_openclprivateaddressspace_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OpenCLPrivateAddressSpace_Keyword_private;
case 1: return clang_ext_OpenCLPrivateAddressSpace_GNU_opencl_private;
case 2: return clang_ext_OpenCLPrivateAddressSpace_CXX11_clang_opencl_private;
case 3: return clang_ext_OpenCLPrivateAddressSpace_C2x_clang_opencl_private;
case 4: return clang_ext_OpenCLPrivateAddressSpace_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_openclprivateaddressspace_spelling_val: %d", Int_val(ocaml));
return clang_ext_OpenCLPrivateAddressSpace_Keyword_private;
}
value
Val_clang_ext_openclprivateaddressspace_spelling(enum clang_ext_OpenCLPrivateAddressSpace_spelling v)
{
switch (v) {
case clang_ext_OpenCLPrivateAddressSpace_Keyword_private: return Val_int(0);
case clang_ext_OpenCLPrivateAddressSpace_GNU_opencl_private: return Val_int(1);
case clang_ext_OpenCLPrivateAddressSpace_CXX11_clang_opencl_private: return Val_int(2);
case clang_ext_OpenCLPrivateAddressSpace_C2x_clang_opencl_private: return Val_int(3);
case clang_ext_OpenCLPrivateAddressSpace_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_openclprivateaddressspace_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OpenCLPrivateAddressSpace_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OpenCLPrivateAddressSpace_spelling result = clang_ext_OpenCLPrivateAddressSpace_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_openclprivateaddressspace_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_OptimizeNone_spelling
Clang_ext_optimizenone_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OptimizeNone_GNU_optnone;
case 1: return clang_ext_OptimizeNone_CXX11_clang_optnone;
case 2: return clang_ext_OptimizeNone_C2x_clang_optnone;
case 3: return clang_ext_OptimizeNone_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_optimizenone_spelling_val: %d", Int_val(ocaml));
return clang_ext_OptimizeNone_GNU_optnone;
}
value
Val_clang_ext_optimizenone_spelling(enum clang_ext_OptimizeNone_spelling v)
{
switch (v) {
case clang_ext_OptimizeNone_GNU_optnone: return Val_int(0);
case clang_ext_OptimizeNone_CXX11_clang_optnone: return Val_int(1);
case clang_ext_OptimizeNone_C2x_clang_optnone: return Val_int(2);
case clang_ext_OptimizeNone_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_optimizenone_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OptimizeNone_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OptimizeNone_spelling result = clang_ext_OptimizeNone_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_optimizenone_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Overloadable_spelling
Clang_ext_overloadable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Overloadable_GNU_overloadable;
case 1: return clang_ext_Overloadable_CXX11_clang_overloadable;
case 2: return clang_ext_Overloadable_C2x_clang_overloadable;
case 3: return clang_ext_Overloadable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_overloadable_spelling_val: %d", Int_val(ocaml));
return clang_ext_Overloadable_GNU_overloadable;
}
value
Val_clang_ext_overloadable_spelling(enum clang_ext_Overloadable_spelling v)
{
switch (v) {
case clang_ext_Overloadable_GNU_overloadable: return Val_int(0);
case clang_ext_Overloadable_CXX11_clang_overloadable: return Val_int(1);
case clang_ext_Overloadable_C2x_clang_overloadable: return Val_int(2);
case clang_ext_Overloadable_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_overloadable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Overloadable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Overloadable_spelling result = clang_ext_Overloadable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_overloadable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Ownership_spelling
Clang_ext_ownership_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Ownership_GNU_ownership_holds;
case 1: return clang_ext_Ownership_CXX11_clang_ownership_holds;
case 2: return clang_ext_Ownership_C2x_clang_ownership_holds;
case 3: return clang_ext_Ownership_GNU_ownership_returns;
case 4: return clang_ext_Ownership_CXX11_clang_ownership_returns;
case 5: return clang_ext_Ownership_C2x_clang_ownership_returns;
case 6: return clang_ext_Ownership_GNU_ownership_takes;
case 7: return clang_ext_Ownership_CXX11_clang_ownership_takes;
case 8: return clang_ext_Ownership_C2x_clang_ownership_takes;
case 9: return clang_ext_Ownership_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_ownership_spelling_val: %d", Int_val(ocaml));
return clang_ext_Ownership_GNU_ownership_holds;
}
value
Val_clang_ext_ownership_spelling(enum clang_ext_Ownership_spelling v)
{
switch (v) {
case clang_ext_Ownership_GNU_ownership_holds: return Val_int(0);
case clang_ext_Ownership_CXX11_clang_ownership_holds: return Val_int(1);
case clang_ext_Ownership_C2x_clang_ownership_holds: return Val_int(2);
case clang_ext_Ownership_GNU_ownership_returns: return Val_int(3);
case clang_ext_Ownership_CXX11_clang_ownership_returns: return Val_int(4);
case clang_ext_Ownership_C2x_clang_ownership_returns: return Val_int(5);
case clang_ext_Ownership_GNU_ownership_takes: return Val_int(6);
case clang_ext_Ownership_CXX11_clang_ownership_takes: return Val_int(7);
case clang_ext_Ownership_C2x_clang_ownership_takes: return Val_int(8);
case clang_ext_Ownership_SpellingNotCalculated: return Val_int(9);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ownership_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Ownership_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Ownership_spelling result = clang_ext_Ownership_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ownership_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Packed_spelling
Clang_ext_packed_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Packed_GNU_packed;
case 1: return clang_ext_Packed_CXX11_gnu_packed;
case 2: return clang_ext_Packed_C2x_gnu_packed;
case 3: return clang_ext_Packed_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_packed_spelling_val: %d", Int_val(ocaml));
return clang_ext_Packed_GNU_packed;
}
value
Val_clang_ext_packed_spelling(enum clang_ext_Packed_spelling v)
{
switch (v) {
case clang_ext_Packed_GNU_packed: return Val_int(0);
case clang_ext_Packed_CXX11_gnu_packed: return Val_int(1);
case clang_ext_Packed_C2x_gnu_packed: return Val_int(2);
case clang_ext_Packed_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_packed_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Packed_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Packed_spelling result = clang_ext_Packed_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_packed_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ParamTypestate_spelling
Clang_ext_paramtypestate_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ParamTypestate_GNU_param_typestate;
case 1: return clang_ext_ParamTypestate_CXX11_clang_param_typestate;
case 2: return clang_ext_ParamTypestate_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_paramtypestate_spelling_val: %d", Int_val(ocaml));
return clang_ext_ParamTypestate_GNU_param_typestate;
}
value
Val_clang_ext_paramtypestate_spelling(enum clang_ext_ParamTypestate_spelling v)
{
switch (v) {
case clang_ext_ParamTypestate_GNU_param_typestate: return Val_int(0);
case clang_ext_ParamTypestate_CXX11_clang_param_typestate: return Val_int(1);
case clang_ext_ParamTypestate_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_paramtypestate_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ParamTypestate_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ParamTypestate_spelling result = clang_ext_ParamTypestate_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_paramtypestate_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Pascal_spelling
Clang_ext_pascal_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Pascal_GNU_pascal;
case 1: return clang_ext_Pascal_CXX11_clang_pascal;
case 2: return clang_ext_Pascal_C2x_clang_pascal;
case 3: return clang_ext_Pascal_Keyword_pascal;
case 4: return clang_ext_Pascal_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_pascal_spelling_val: %d", Int_val(ocaml));
return clang_ext_Pascal_GNU_pascal;
}
value
Val_clang_ext_pascal_spelling(enum clang_ext_Pascal_spelling v)
{
switch (v) {
case clang_ext_Pascal_GNU_pascal: return Val_int(0);
case clang_ext_Pascal_CXX11_clang_pascal: return Val_int(1);
case clang_ext_Pascal_C2x_clang_pascal: return Val_int(2);
case clang_ext_Pascal_Keyword_pascal: return Val_int(3);
case clang_ext_Pascal_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_pascal_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Pascal_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Pascal_spelling result = clang_ext_Pascal_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_pascal_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_PassObjectSize_spelling
Clang_ext_passobjectsize_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PassObjectSize_GNU_pass_object_size;
case 1: return clang_ext_PassObjectSize_CXX11_clang_pass_object_size;
case 2: return clang_ext_PassObjectSize_C2x_clang_pass_object_size;
case 3: return clang_ext_PassObjectSize_GNU_pass_dynamic_object_size;
case 4: return clang_ext_PassObjectSize_CXX11_clang_pass_dynamic_object_size;
case 5: return clang_ext_PassObjectSize_C2x_clang_pass_dynamic_object_size;
case 6: return clang_ext_PassObjectSize_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_passobjectsize_spelling_val: %d", Int_val(ocaml));
return clang_ext_PassObjectSize_GNU_pass_object_size;
}
value
Val_clang_ext_passobjectsize_spelling(enum clang_ext_PassObjectSize_spelling v)
{
switch (v) {
case clang_ext_PassObjectSize_GNU_pass_object_size: return Val_int(0);
case clang_ext_PassObjectSize_CXX11_clang_pass_object_size: return Val_int(1);
case clang_ext_PassObjectSize_C2x_clang_pass_object_size: return Val_int(2);
case clang_ext_PassObjectSize_GNU_pass_dynamic_object_size: return Val_int(3);
case clang_ext_PassObjectSize_CXX11_clang_pass_dynamic_object_size: return Val_int(4);
case clang_ext_PassObjectSize_C2x_clang_pass_dynamic_object_size: return Val_int(5);
case clang_ext_PassObjectSize_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_passobjectsize_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PassObjectSize_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_PassObjectSize_spelling result = clang_ext_PassObjectSize_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_passobjectsize_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_PatchableFunctionEntry_spelling
Clang_ext_patchablefunctionentry_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PatchableFunctionEntry_GNU_patchable_function_entry;
case 1: return clang_ext_PatchableFunctionEntry_CXX11_gnu_patchable_function_entry;
case 2: return clang_ext_PatchableFunctionEntry_C2x_gnu_patchable_function_entry;
case 3: return clang_ext_PatchableFunctionEntry_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_patchablefunctionentry_spelling_val: %d", Int_val(ocaml));
return clang_ext_PatchableFunctionEntry_GNU_patchable_function_entry;
}
value
Val_clang_ext_patchablefunctionentry_spelling(enum clang_ext_PatchableFunctionEntry_spelling v)
{
switch (v) {
case clang_ext_PatchableFunctionEntry_GNU_patchable_function_entry: return Val_int(0);
case clang_ext_PatchableFunctionEntry_CXX11_gnu_patchable_function_entry: return Val_int(1);
case clang_ext_PatchableFunctionEntry_C2x_gnu_patchable_function_entry: return Val_int(2);
case clang_ext_PatchableFunctionEntry_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_patchablefunctionentry_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PatchableFunctionEntry_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_PatchableFunctionEntry_spelling result = clang_ext_PatchableFunctionEntry_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_patchablefunctionentry_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Pcs_spelling
Clang_ext_pcs_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Pcs_GNU_pcs;
case 1: return clang_ext_Pcs_CXX11_gnu_pcs;
case 2: return clang_ext_Pcs_C2x_gnu_pcs;
case 3: return clang_ext_Pcs_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_pcs_spelling_val: %d", Int_val(ocaml));
return clang_ext_Pcs_GNU_pcs;
}
value
Val_clang_ext_pcs_spelling(enum clang_ext_Pcs_spelling v)
{
switch (v) {
case clang_ext_Pcs_GNU_pcs: return Val_int(0);
case clang_ext_Pcs_CXX11_gnu_pcs: return Val_int(1);
case clang_ext_Pcs_C2x_gnu_pcs: return Val_int(2);
case clang_ext_Pcs_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_pcs_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Pcs_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Pcs_spelling result = clang_ext_Pcs_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_pcs_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_PreferredName_spelling
Clang_ext_preferredname_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PreferredName_GNU_preferred_name;
case 1: return clang_ext_PreferredName_CXX11_clang_preferred_name;
case 2: return clang_ext_PreferredName_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_preferredname_spelling_val: %d", Int_val(ocaml));
return clang_ext_PreferredName_GNU_preferred_name;
}
value
Val_clang_ext_preferredname_spelling(enum clang_ext_PreferredName_spelling v)
{
switch (v) {
case clang_ext_PreferredName_GNU_preferred_name: return Val_int(0);
case clang_ext_PreferredName_CXX11_clang_preferred_name: return Val_int(1);
case clang_ext_PreferredName_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_preferredname_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PreferredName_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_PreferredName_spelling result = clang_ext_PreferredName_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_preferredname_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_PreserveAll_spelling
Clang_ext_preserveall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PreserveAll_GNU_preserve_all;
case 1: return clang_ext_PreserveAll_CXX11_clang_preserve_all;
case 2: return clang_ext_PreserveAll_C2x_clang_preserve_all;
case 3: return clang_ext_PreserveAll_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_preserveall_spelling_val: %d", Int_val(ocaml));
return clang_ext_PreserveAll_GNU_preserve_all;
}
value
Val_clang_ext_preserveall_spelling(enum clang_ext_PreserveAll_spelling v)
{
switch (v) {
case clang_ext_PreserveAll_GNU_preserve_all: return Val_int(0);
case clang_ext_PreserveAll_CXX11_clang_preserve_all: return Val_int(1);
case clang_ext_PreserveAll_C2x_clang_preserve_all: return Val_int(2);
case clang_ext_PreserveAll_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_preserveall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PreserveAll_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_PreserveAll_spelling result = clang_ext_PreserveAll_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_preserveall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_PreserveMost_spelling
Clang_ext_preservemost_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PreserveMost_GNU_preserve_most;
case 1: return clang_ext_PreserveMost_CXX11_clang_preserve_most;
case 2: return clang_ext_PreserveMost_C2x_clang_preserve_most;
case 3: return clang_ext_PreserveMost_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_preservemost_spelling_val: %d", Int_val(ocaml));
return clang_ext_PreserveMost_GNU_preserve_most;
}
value
Val_clang_ext_preservemost_spelling(enum clang_ext_PreserveMost_spelling v)
{
switch (v) {
case clang_ext_PreserveMost_GNU_preserve_most: return Val_int(0);
case clang_ext_PreserveMost_CXX11_clang_preserve_most: return Val_int(1);
case clang_ext_PreserveMost_C2x_clang_preserve_most: return Val_int(2);
case clang_ext_PreserveMost_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_preservemost_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PreserveMost_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_PreserveMost_spelling result = clang_ext_PreserveMost_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_preservemost_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_PtGuardedVar_spelling
Clang_ext_ptguardedvar_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PtGuardedVar_GNU_pt_guarded_var;
case 1: return clang_ext_PtGuardedVar_CXX11_clang_pt_guarded_var;
case 2: return clang_ext_PtGuardedVar_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_ptguardedvar_spelling_val: %d", Int_val(ocaml));
return clang_ext_PtGuardedVar_GNU_pt_guarded_var;
}
value
Val_clang_ext_ptguardedvar_spelling(enum clang_ext_PtGuardedVar_spelling v)
{
switch (v) {
case clang_ext_PtGuardedVar_GNU_pt_guarded_var: return Val_int(0);
case clang_ext_PtGuardedVar_CXX11_clang_pt_guarded_var: return Val_int(1);
case clang_ext_PtGuardedVar_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ptguardedvar_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PtGuardedVar_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_PtGuardedVar_spelling result = clang_ext_PtGuardedVar_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ptguardedvar_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Pure_spelling
Clang_ext_pure_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Pure_GNU_pure;
case 1: return clang_ext_Pure_CXX11_gnu_pure;
case 2: return clang_ext_Pure_C2x_gnu_pure;
case 3: return clang_ext_Pure_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_pure_spelling_val: %d", Int_val(ocaml));
return clang_ext_Pure_GNU_pure;
}
value
Val_clang_ext_pure_spelling(enum clang_ext_Pure_spelling v)
{
switch (v) {
case clang_ext_Pure_GNU_pure: return Val_int(0);
case clang_ext_Pure_CXX11_gnu_pure: return Val_int(1);
case clang_ext_Pure_C2x_gnu_pure: return Val_int(2);
case clang_ext_Pure_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_pure_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Pure_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Pure_spelling result = clang_ext_Pure_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_pure_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_RISCVInterrupt_spelling
Clang_ext_riscvinterrupt_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_RISCVInterrupt_GNU_interrupt;
case 1: return clang_ext_RISCVInterrupt_CXX11_gnu_interrupt;
case 2: return clang_ext_RISCVInterrupt_C2x_gnu_interrupt;
case 3: return clang_ext_RISCVInterrupt_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_riscvinterrupt_spelling_val: %d", Int_val(ocaml));
return clang_ext_RISCVInterrupt_GNU_interrupt;
}
value
Val_clang_ext_riscvinterrupt_spelling(enum clang_ext_RISCVInterrupt_spelling v)
{
switch (v) {
case clang_ext_RISCVInterrupt_GNU_interrupt: return Val_int(0);
case clang_ext_RISCVInterrupt_CXX11_gnu_interrupt: return Val_int(1);
case clang_ext_RISCVInterrupt_C2x_gnu_interrupt: return Val_int(2);
case clang_ext_RISCVInterrupt_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_riscvinterrupt_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_RISCVInterrupt_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_RISCVInterrupt_spelling result = clang_ext_RISCVInterrupt_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_riscvinterrupt_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_RandomizeLayout_spelling
Clang_ext_randomizelayout_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_RandomizeLayout_GNU_randomize_layout;
case 1: return clang_ext_RandomizeLayout_CXX11_gnu_randomize_layout;
case 2: return clang_ext_RandomizeLayout_C2x_gnu_randomize_layout;
case 3: return clang_ext_RandomizeLayout_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_randomizelayout_spelling_val: %d", Int_val(ocaml));
return clang_ext_RandomizeLayout_GNU_randomize_layout;
}
value
Val_clang_ext_randomizelayout_spelling(enum clang_ext_RandomizeLayout_spelling v)
{
switch (v) {
case clang_ext_RandomizeLayout_GNU_randomize_layout: return Val_int(0);
case clang_ext_RandomizeLayout_CXX11_gnu_randomize_layout: return Val_int(1);
case clang_ext_RandomizeLayout_C2x_gnu_randomize_layout: return Val_int(2);
case clang_ext_RandomizeLayout_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_randomizelayout_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_RandomizeLayout_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_RandomizeLayout_spelling result = clang_ext_RandomizeLayout_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_randomizelayout_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_RegCall_spelling
Clang_ext_regcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_RegCall_GNU_regcall;
case 1: return clang_ext_RegCall_CXX11_gnu_regcall;
case 2: return clang_ext_RegCall_C2x_gnu_regcall;
case 3: return clang_ext_RegCall_Keyword_regcall;
case 4: return clang_ext_RegCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_regcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_RegCall_GNU_regcall;
}
value
Val_clang_ext_regcall_spelling(enum clang_ext_RegCall_spelling v)
{
switch (v) {
case clang_ext_RegCall_GNU_regcall: return Val_int(0);
case clang_ext_RegCall_CXX11_gnu_regcall: return Val_int(1);
case clang_ext_RegCall_C2x_gnu_regcall: return Val_int(2);
case clang_ext_RegCall_Keyword_regcall: return Val_int(3);
case clang_ext_RegCall_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_regcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_RegCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_RegCall_spelling result = clang_ext_RegCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_regcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Reinitializes_spelling
Clang_ext_reinitializes_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Reinitializes_GNU_reinitializes;
case 1: return clang_ext_Reinitializes_CXX11_clang_reinitializes;
case 2: return clang_ext_Reinitializes_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_reinitializes_spelling_val: %d", Int_val(ocaml));
return clang_ext_Reinitializes_GNU_reinitializes;
}
value
Val_clang_ext_reinitializes_spelling(enum clang_ext_Reinitializes_spelling v)
{
switch (v) {
case clang_ext_Reinitializes_GNU_reinitializes: return Val_int(0);
case clang_ext_Reinitializes_CXX11_clang_reinitializes: return Val_int(1);
case clang_ext_Reinitializes_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_reinitializes_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Reinitializes_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Reinitializes_spelling result = clang_ext_Reinitializes_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_reinitializes_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ReleaseCapability_spelling
Clang_ext_releasecapability_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ReleaseCapability_GNU_release_capability;
case 1: return clang_ext_ReleaseCapability_CXX11_clang_release_capability;
case 2: return clang_ext_ReleaseCapability_GNU_release_shared_capability;
case 3: return clang_ext_ReleaseCapability_CXX11_clang_release_shared_capability;
case 4: return clang_ext_ReleaseCapability_GNU_release_generic_capability;
case 5: return clang_ext_ReleaseCapability_CXX11_clang_release_generic_capability;
case 6: return clang_ext_ReleaseCapability_GNU_unlock_function;
case 7: return clang_ext_ReleaseCapability_CXX11_clang_unlock_function;
case 8: return clang_ext_ReleaseCapability_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_releasecapability_spelling_val: %d", Int_val(ocaml));
return clang_ext_ReleaseCapability_GNU_release_capability;
}
value
Val_clang_ext_releasecapability_spelling(enum clang_ext_ReleaseCapability_spelling v)
{
switch (v) {
case clang_ext_ReleaseCapability_GNU_release_capability: return Val_int(0);
case clang_ext_ReleaseCapability_CXX11_clang_release_capability: return Val_int(1);
case clang_ext_ReleaseCapability_GNU_release_shared_capability: return Val_int(2);
case clang_ext_ReleaseCapability_CXX11_clang_release_shared_capability: return Val_int(3);
case clang_ext_ReleaseCapability_GNU_release_generic_capability: return Val_int(4);
case clang_ext_ReleaseCapability_CXX11_clang_release_generic_capability: return Val_int(5);
case clang_ext_ReleaseCapability_GNU_unlock_function: return Val_int(6);
case clang_ext_ReleaseCapability_CXX11_clang_unlock_function: return Val_int(7);
case clang_ext_ReleaseCapability_SpellingNotCalculated: return Val_int(8);
}
caml_failwith_fmt("invalid value for Val_clang_ext_releasecapability_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ReleaseCapability_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ReleaseCapability_spelling result = clang_ext_ReleaseCapability_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_releasecapability_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ReleaseHandle_spelling
Clang_ext_releasehandle_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ReleaseHandle_GNU_release_handle;
case 1: return clang_ext_ReleaseHandle_CXX11_clang_release_handle;
case 2: return clang_ext_ReleaseHandle_C2x_clang_release_handle;
case 3: return clang_ext_ReleaseHandle_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_releasehandle_spelling_val: %d", Int_val(ocaml));
return clang_ext_ReleaseHandle_GNU_release_handle;
}
value
Val_clang_ext_releasehandle_spelling(enum clang_ext_ReleaseHandle_spelling v)
{
switch (v) {
case clang_ext_ReleaseHandle_GNU_release_handle: return Val_int(0);
case clang_ext_ReleaseHandle_CXX11_clang_release_handle: return Val_int(1);
case clang_ext_ReleaseHandle_C2x_clang_release_handle: return Val_int(2);
case clang_ext_ReleaseHandle_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_releasehandle_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ReleaseHandle_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ReleaseHandle_spelling result = clang_ext_ReleaseHandle_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_releasehandle_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_RequiresCapability_spelling
Clang_ext_requirescapability_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_RequiresCapability_GNU_requires_capability;
case 1: return clang_ext_RequiresCapability_CXX11_clang_requires_capability;
case 2: return clang_ext_RequiresCapability_GNU_exclusive_locks_required;
case 3: return clang_ext_RequiresCapability_CXX11_clang_exclusive_locks_required;
case 4: return clang_ext_RequiresCapability_GNU_requires_shared_capability;
case 5: return clang_ext_RequiresCapability_CXX11_clang_requires_shared_capability;
case 6: return clang_ext_RequiresCapability_GNU_shared_locks_required;
case 7: return clang_ext_RequiresCapability_CXX11_clang_shared_locks_required;
case 8: return clang_ext_RequiresCapability_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_requirescapability_spelling_val: %d", Int_val(ocaml));
return clang_ext_RequiresCapability_GNU_requires_capability;
}
value
Val_clang_ext_requirescapability_spelling(enum clang_ext_RequiresCapability_spelling v)
{
switch (v) {
case clang_ext_RequiresCapability_GNU_requires_capability: return Val_int(0);
case clang_ext_RequiresCapability_CXX11_clang_requires_capability: return Val_int(1);
case clang_ext_RequiresCapability_GNU_exclusive_locks_required: return Val_int(2);
case clang_ext_RequiresCapability_CXX11_clang_exclusive_locks_required: return Val_int(3);
case clang_ext_RequiresCapability_GNU_requires_shared_capability: return Val_int(4);
case clang_ext_RequiresCapability_CXX11_clang_requires_shared_capability: return Val_int(5);
case clang_ext_RequiresCapability_GNU_shared_locks_required: return Val_int(6);
case clang_ext_RequiresCapability_CXX11_clang_shared_locks_required: return Val_int(7);
case clang_ext_RequiresCapability_SpellingNotCalculated: return Val_int(8);
}
caml_failwith_fmt("invalid value for Val_clang_ext_requirescapability_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_RequiresCapability_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_RequiresCapability_spelling result = clang_ext_RequiresCapability_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_requirescapability_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Restrict_spelling
Clang_ext_restrict_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Restrict_Declspec_restrict;
case 1: return clang_ext_Restrict_GNU_malloc;
case 2: return clang_ext_Restrict_CXX11_gnu_malloc;
case 3: return clang_ext_Restrict_C2x_gnu_malloc;
case 4: return clang_ext_Restrict_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_restrict_spelling_val: %d", Int_val(ocaml));
return clang_ext_Restrict_Declspec_restrict;
}
value
Val_clang_ext_restrict_spelling(enum clang_ext_Restrict_spelling v)
{
switch (v) {
case clang_ext_Restrict_Declspec_restrict: return Val_int(0);
case clang_ext_Restrict_GNU_malloc: return Val_int(1);
case clang_ext_Restrict_CXX11_gnu_malloc: return Val_int(2);
case clang_ext_Restrict_C2x_gnu_malloc: return Val_int(3);
case clang_ext_Restrict_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_restrict_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Restrict_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Restrict_spelling result = clang_ext_Restrict_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_restrict_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Retain_spelling
Clang_ext_retain_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Retain_GNU_retain;
case 1: return clang_ext_Retain_CXX11_gnu_retain;
case 2: return clang_ext_Retain_C2x_gnu_retain;
case 3: return clang_ext_Retain_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_retain_spelling_val: %d", Int_val(ocaml));
return clang_ext_Retain_GNU_retain;
}
value
Val_clang_ext_retain_spelling(enum clang_ext_Retain_spelling v)
{
switch (v) {
case clang_ext_Retain_GNU_retain: return Val_int(0);
case clang_ext_Retain_CXX11_gnu_retain: return Val_int(1);
case clang_ext_Retain_C2x_gnu_retain: return Val_int(2);
case clang_ext_Retain_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_retain_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Retain_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Retain_spelling result = clang_ext_Retain_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_retain_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ReturnTypestate_spelling
Clang_ext_returntypestate_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ReturnTypestate_GNU_return_typestate;
case 1: return clang_ext_ReturnTypestate_CXX11_clang_return_typestate;
case 2: return clang_ext_ReturnTypestate_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_returntypestate_spelling_val: %d", Int_val(ocaml));
return clang_ext_ReturnTypestate_GNU_return_typestate;
}
value
Val_clang_ext_returntypestate_spelling(enum clang_ext_ReturnTypestate_spelling v)
{
switch (v) {
case clang_ext_ReturnTypestate_GNU_return_typestate: return Val_int(0);
case clang_ext_ReturnTypestate_CXX11_clang_return_typestate: return Val_int(1);
case clang_ext_ReturnTypestate_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_returntypestate_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ReturnTypestate_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ReturnTypestate_spelling result = clang_ext_ReturnTypestate_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_returntypestate_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ReturnsNonNull_spelling
Clang_ext_returnsnonnull_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ReturnsNonNull_GNU_returns_nonnull;
case 1: return clang_ext_ReturnsNonNull_CXX11_gnu_returns_nonnull;
case 2: return clang_ext_ReturnsNonNull_C2x_gnu_returns_nonnull;
case 3: return clang_ext_ReturnsNonNull_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_returnsnonnull_spelling_val: %d", Int_val(ocaml));
return clang_ext_ReturnsNonNull_GNU_returns_nonnull;
}
value
Val_clang_ext_returnsnonnull_spelling(enum clang_ext_ReturnsNonNull_spelling v)
{
switch (v) {
case clang_ext_ReturnsNonNull_GNU_returns_nonnull: return Val_int(0);
case clang_ext_ReturnsNonNull_CXX11_gnu_returns_nonnull: return Val_int(1);
case clang_ext_ReturnsNonNull_C2x_gnu_returns_nonnull: return Val_int(2);
case clang_ext_ReturnsNonNull_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_returnsnonnull_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ReturnsNonNull_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ReturnsNonNull_spelling result = clang_ext_ReturnsNonNull_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_returnsnonnull_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ReturnsTwice_spelling
Clang_ext_returnstwice_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ReturnsTwice_GNU_returns_twice;
case 1: return clang_ext_ReturnsTwice_CXX11_gnu_returns_twice;
case 2: return clang_ext_ReturnsTwice_C2x_gnu_returns_twice;
case 3: return clang_ext_ReturnsTwice_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_returnstwice_spelling_val: %d", Int_val(ocaml));
return clang_ext_ReturnsTwice_GNU_returns_twice;
}
value
Val_clang_ext_returnstwice_spelling(enum clang_ext_ReturnsTwice_spelling v)
{
switch (v) {
case clang_ext_ReturnsTwice_GNU_returns_twice: return Val_int(0);
case clang_ext_ReturnsTwice_CXX11_gnu_returns_twice: return Val_int(1);
case clang_ext_ReturnsTwice_C2x_gnu_returns_twice: return Val_int(2);
case clang_ext_ReturnsTwice_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_returnstwice_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ReturnsTwice_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ReturnsTwice_spelling result = clang_ext_ReturnsTwice_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_returnstwice_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SYCLKernel_spelling
Clang_ext_syclkernel_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SYCLKernel_GNU_sycl_kernel;
case 1: return clang_ext_SYCLKernel_CXX11_clang_sycl_kernel;
case 2: return clang_ext_SYCLKernel_C2x_clang_sycl_kernel;
case 3: return clang_ext_SYCLKernel_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_syclkernel_spelling_val: %d", Int_val(ocaml));
return clang_ext_SYCLKernel_GNU_sycl_kernel;
}
value
Val_clang_ext_syclkernel_spelling(enum clang_ext_SYCLKernel_spelling v)
{
switch (v) {
case clang_ext_SYCLKernel_GNU_sycl_kernel: return Val_int(0);
case clang_ext_SYCLKernel_CXX11_clang_sycl_kernel: return Val_int(1);
case clang_ext_SYCLKernel_C2x_clang_sycl_kernel: return Val_int(2);
case clang_ext_SYCLKernel_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_syclkernel_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SYCLKernel_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SYCLKernel_spelling result = clang_ext_SYCLKernel_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_syclkernel_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SYCLSpecialClass_spelling
Clang_ext_syclspecialclass_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SYCLSpecialClass_GNU_sycl_special_class;
case 1: return clang_ext_SYCLSpecialClass_CXX11_clang_sycl_special_class;
case 2: return clang_ext_SYCLSpecialClass_C2x_clang_sycl_special_class;
case 3: return clang_ext_SYCLSpecialClass_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_syclspecialclass_spelling_val: %d", Int_val(ocaml));
return clang_ext_SYCLSpecialClass_GNU_sycl_special_class;
}
value
Val_clang_ext_syclspecialclass_spelling(enum clang_ext_SYCLSpecialClass_spelling v)
{
switch (v) {
case clang_ext_SYCLSpecialClass_GNU_sycl_special_class: return Val_int(0);
case clang_ext_SYCLSpecialClass_CXX11_clang_sycl_special_class: return Val_int(1);
case clang_ext_SYCLSpecialClass_C2x_clang_sycl_special_class: return Val_int(2);
case clang_ext_SYCLSpecialClass_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_syclspecialclass_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SYCLSpecialClass_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SYCLSpecialClass_spelling result = clang_ext_SYCLSpecialClass_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_syclspecialclass_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ScopedLockable_spelling
Clang_ext_scopedlockable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ScopedLockable_GNU_scoped_lockable;
case 1: return clang_ext_ScopedLockable_CXX11_clang_scoped_lockable;
case 2: return clang_ext_ScopedLockable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_scopedlockable_spelling_val: %d", Int_val(ocaml));
return clang_ext_ScopedLockable_GNU_scoped_lockable;
}
value
Val_clang_ext_scopedlockable_spelling(enum clang_ext_ScopedLockable_spelling v)
{
switch (v) {
case clang_ext_ScopedLockable_GNU_scoped_lockable: return Val_int(0);
case clang_ext_ScopedLockable_CXX11_clang_scoped_lockable: return Val_int(1);
case clang_ext_ScopedLockable_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_scopedlockable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ScopedLockable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ScopedLockable_spelling result = clang_ext_ScopedLockable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_scopedlockable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Section_spelling
Clang_ext_section_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Section_GNU_section;
case 1: return clang_ext_Section_CXX11_gnu_section;
case 2: return clang_ext_Section_C2x_gnu_section;
case 3: return clang_ext_Section_Declspec_allocate;
case 4: return clang_ext_Section_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_section_spelling_val: %d", Int_val(ocaml));
return clang_ext_Section_GNU_section;
}
value
Val_clang_ext_section_spelling(enum clang_ext_Section_spelling v)
{
switch (v) {
case clang_ext_Section_GNU_section: return Val_int(0);
case clang_ext_Section_CXX11_gnu_section: return Val_int(1);
case clang_ext_Section_C2x_gnu_section: return Val_int(2);
case clang_ext_Section_Declspec_allocate: return Val_int(3);
case clang_ext_Section_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_section_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Section_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Section_spelling result = clang_ext_Section_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_section_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SelectAny_spelling
Clang_ext_selectany_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SelectAny_Declspec_selectany;
case 1: return clang_ext_SelectAny_GNU_selectany;
case 2: return clang_ext_SelectAny_CXX11_gnu_selectany;
case 3: return clang_ext_SelectAny_C2x_gnu_selectany;
case 4: return clang_ext_SelectAny_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_selectany_spelling_val: %d", Int_val(ocaml));
return clang_ext_SelectAny_Declspec_selectany;
}
value
Val_clang_ext_selectany_spelling(enum clang_ext_SelectAny_spelling v)
{
switch (v) {
case clang_ext_SelectAny_Declspec_selectany: return Val_int(0);
case clang_ext_SelectAny_GNU_selectany: return Val_int(1);
case clang_ext_SelectAny_CXX11_gnu_selectany: return Val_int(2);
case clang_ext_SelectAny_C2x_gnu_selectany: return Val_int(3);
case clang_ext_SelectAny_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_selectany_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SelectAny_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SelectAny_spelling result = clang_ext_SelectAny_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_selectany_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Sentinel_spelling
Clang_ext_sentinel_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Sentinel_GNU_sentinel;
case 1: return clang_ext_Sentinel_CXX11_gnu_sentinel;
case 2: return clang_ext_Sentinel_C2x_gnu_sentinel;
case 3: return clang_ext_Sentinel_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_sentinel_spelling_val: %d", Int_val(ocaml));
return clang_ext_Sentinel_GNU_sentinel;
}
value
Val_clang_ext_sentinel_spelling(enum clang_ext_Sentinel_spelling v)
{
switch (v) {
case clang_ext_Sentinel_GNU_sentinel: return Val_int(0);
case clang_ext_Sentinel_CXX11_gnu_sentinel: return Val_int(1);
case clang_ext_Sentinel_C2x_gnu_sentinel: return Val_int(2);
case clang_ext_Sentinel_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_sentinel_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Sentinel_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Sentinel_spelling result = clang_ext_Sentinel_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_sentinel_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SetTypestate_spelling
Clang_ext_settypestate_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SetTypestate_GNU_set_typestate;
case 1: return clang_ext_SetTypestate_CXX11_clang_set_typestate;
case 2: return clang_ext_SetTypestate_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_settypestate_spelling_val: %d", Int_val(ocaml));
return clang_ext_SetTypestate_GNU_set_typestate;
}
value
Val_clang_ext_settypestate_spelling(enum clang_ext_SetTypestate_spelling v)
{
switch (v) {
case clang_ext_SetTypestate_GNU_set_typestate: return Val_int(0);
case clang_ext_SetTypestate_CXX11_clang_set_typestate: return Val_int(1);
case clang_ext_SetTypestate_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_settypestate_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SetTypestate_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SetTypestate_spelling result = clang_ext_SetTypestate_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_settypestate_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SpeculativeLoadHardening_spelling
Clang_ext_speculativeloadhardening_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SpeculativeLoadHardening_GNU_speculative_load_hardening;
case 1: return clang_ext_SpeculativeLoadHardening_CXX11_clang_speculative_load_hardening;
case 2: return clang_ext_SpeculativeLoadHardening_C2x_clang_speculative_load_hardening;
case 3: return clang_ext_SpeculativeLoadHardening_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_speculativeloadhardening_spelling_val: %d", Int_val(ocaml));
return clang_ext_SpeculativeLoadHardening_GNU_speculative_load_hardening;
}
value
Val_clang_ext_speculativeloadhardening_spelling(enum clang_ext_SpeculativeLoadHardening_spelling v)
{
switch (v) {
case clang_ext_SpeculativeLoadHardening_GNU_speculative_load_hardening: return Val_int(0);
case clang_ext_SpeculativeLoadHardening_CXX11_clang_speculative_load_hardening: return Val_int(1);
case clang_ext_SpeculativeLoadHardening_C2x_clang_speculative_load_hardening: return Val_int(2);
case clang_ext_SpeculativeLoadHardening_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_speculativeloadhardening_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SpeculativeLoadHardening_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SpeculativeLoadHardening_spelling result = clang_ext_SpeculativeLoadHardening_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_speculativeloadhardening_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_StandaloneDebug_spelling
Clang_ext_standalonedebug_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_StandaloneDebug_GNU_standalone_debug;
case 1: return clang_ext_StandaloneDebug_CXX11_clang_standalone_debug;
case 2: return clang_ext_StandaloneDebug_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_standalonedebug_spelling_val: %d", Int_val(ocaml));
return clang_ext_StandaloneDebug_GNU_standalone_debug;
}
value
Val_clang_ext_standalonedebug_spelling(enum clang_ext_StandaloneDebug_spelling v)
{
switch (v) {
case clang_ext_StandaloneDebug_GNU_standalone_debug: return Val_int(0);
case clang_ext_StandaloneDebug_CXX11_clang_standalone_debug: return Val_int(1);
case clang_ext_StandaloneDebug_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_standalonedebug_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_StandaloneDebug_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_StandaloneDebug_spelling result = clang_ext_StandaloneDebug_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_standalonedebug_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_StdCall_spelling
Clang_ext_stdcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_StdCall_GNU_stdcall;
case 1: return clang_ext_StdCall_CXX11_gnu_stdcall;
case 2: return clang_ext_StdCall_C2x_gnu_stdcall;
case 3: return clang_ext_StdCall_Keyword_stdcall;
case 4: return clang_ext_StdCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_stdcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_StdCall_GNU_stdcall;
}
value
Val_clang_ext_stdcall_spelling(enum clang_ext_StdCall_spelling v)
{
switch (v) {
case clang_ext_StdCall_GNU_stdcall: return Val_int(0);
case clang_ext_StdCall_CXX11_gnu_stdcall: return Val_int(1);
case clang_ext_StdCall_C2x_gnu_stdcall: return Val_int(2);
case clang_ext_StdCall_Keyword_stdcall: return Val_int(3);
case clang_ext_StdCall_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_stdcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_StdCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_StdCall_spelling result = clang_ext_StdCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_stdcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftAsync_spelling
Clang_ext_swiftasync_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftAsync_GNU_swift_async;
case 1: return clang_ext_SwiftAsync_CXX11_clang_swift_async;
case 2: return clang_ext_SwiftAsync_C2x_clang_swift_async;
case 3: return clang_ext_SwiftAsync_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftasync_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftAsync_GNU_swift_async;
}
value
Val_clang_ext_swiftasync_spelling(enum clang_ext_SwiftAsync_spelling v)
{
switch (v) {
case clang_ext_SwiftAsync_GNU_swift_async: return Val_int(0);
case clang_ext_SwiftAsync_CXX11_clang_swift_async: return Val_int(1);
case clang_ext_SwiftAsync_C2x_clang_swift_async: return Val_int(2);
case clang_ext_SwiftAsync_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftasync_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftAsync_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftAsync_spelling result = clang_ext_SwiftAsync_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftasync_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftAsyncCall_spelling
Clang_ext_swiftasynccall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftAsyncCall_GNU_swiftasynccall;
case 1: return clang_ext_SwiftAsyncCall_CXX11_clang_swiftasynccall;
case 2: return clang_ext_SwiftAsyncCall_C2x_clang_swiftasynccall;
case 3: return clang_ext_SwiftAsyncCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftasynccall_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftAsyncCall_GNU_swiftasynccall;
}
value
Val_clang_ext_swiftasynccall_spelling(enum clang_ext_SwiftAsyncCall_spelling v)
{
switch (v) {
case clang_ext_SwiftAsyncCall_GNU_swiftasynccall: return Val_int(0);
case clang_ext_SwiftAsyncCall_CXX11_clang_swiftasynccall: return Val_int(1);
case clang_ext_SwiftAsyncCall_C2x_clang_swiftasynccall: return Val_int(2);
case clang_ext_SwiftAsyncCall_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftasynccall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftAsyncCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftAsyncCall_spelling result = clang_ext_SwiftAsyncCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftasynccall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftAsyncContext_spelling
Clang_ext_swiftasynccontext_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftAsyncContext_GNU_swift_async_context;
case 1: return clang_ext_SwiftAsyncContext_CXX11_clang_swift_async_context;
case 2: return clang_ext_SwiftAsyncContext_C2x_clang_swift_async_context;
case 3: return clang_ext_SwiftAsyncContext_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftasynccontext_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftAsyncContext_GNU_swift_async_context;
}
value
Val_clang_ext_swiftasynccontext_spelling(enum clang_ext_SwiftAsyncContext_spelling v)
{
switch (v) {
case clang_ext_SwiftAsyncContext_GNU_swift_async_context: return Val_int(0);
case clang_ext_SwiftAsyncContext_CXX11_clang_swift_async_context: return Val_int(1);
case clang_ext_SwiftAsyncContext_C2x_clang_swift_async_context: return Val_int(2);
case clang_ext_SwiftAsyncContext_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftasynccontext_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftAsyncContext_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftAsyncContext_spelling result = clang_ext_SwiftAsyncContext_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftasynccontext_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftAsyncError_spelling
Clang_ext_swiftasyncerror_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftAsyncError_GNU_swift_async_error;
case 1: return clang_ext_SwiftAsyncError_CXX11_clang_swift_async_error;
case 2: return clang_ext_SwiftAsyncError_C2x_clang_swift_async_error;
case 3: return clang_ext_SwiftAsyncError_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftasyncerror_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftAsyncError_GNU_swift_async_error;
}
value
Val_clang_ext_swiftasyncerror_spelling(enum clang_ext_SwiftAsyncError_spelling v)
{
switch (v) {
case clang_ext_SwiftAsyncError_GNU_swift_async_error: return Val_int(0);
case clang_ext_SwiftAsyncError_CXX11_clang_swift_async_error: return Val_int(1);
case clang_ext_SwiftAsyncError_C2x_clang_swift_async_error: return Val_int(2);
case clang_ext_SwiftAsyncError_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftasyncerror_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftAsyncError_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftAsyncError_spelling result = clang_ext_SwiftAsyncError_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftasyncerror_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftCall_spelling
Clang_ext_swiftcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftCall_GNU_swiftcall;
case 1: return clang_ext_SwiftCall_CXX11_clang_swiftcall;
case 2: return clang_ext_SwiftCall_C2x_clang_swiftcall;
case 3: return clang_ext_SwiftCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftCall_GNU_swiftcall;
}
value
Val_clang_ext_swiftcall_spelling(enum clang_ext_SwiftCall_spelling v)
{
switch (v) {
case clang_ext_SwiftCall_GNU_swiftcall: return Val_int(0);
case clang_ext_SwiftCall_CXX11_clang_swiftcall: return Val_int(1);
case clang_ext_SwiftCall_C2x_clang_swiftcall: return Val_int(2);
case clang_ext_SwiftCall_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftCall_spelling result = clang_ext_SwiftCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftContext_spelling
Clang_ext_swiftcontext_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftContext_GNU_swift_context;
case 1: return clang_ext_SwiftContext_CXX11_clang_swift_context;
case 2: return clang_ext_SwiftContext_C2x_clang_swift_context;
case 3: return clang_ext_SwiftContext_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftcontext_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftContext_GNU_swift_context;
}
value
Val_clang_ext_swiftcontext_spelling(enum clang_ext_SwiftContext_spelling v)
{
switch (v) {
case clang_ext_SwiftContext_GNU_swift_context: return Val_int(0);
case clang_ext_SwiftContext_CXX11_clang_swift_context: return Val_int(1);
case clang_ext_SwiftContext_C2x_clang_swift_context: return Val_int(2);
case clang_ext_SwiftContext_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftcontext_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftContext_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftContext_spelling result = clang_ext_SwiftContext_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftcontext_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftErrorResult_spelling
Clang_ext_swifterrorresult_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftErrorResult_GNU_swift_error_result;
case 1: return clang_ext_SwiftErrorResult_CXX11_clang_swift_error_result;
case 2: return clang_ext_SwiftErrorResult_C2x_clang_swift_error_result;
case 3: return clang_ext_SwiftErrorResult_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swifterrorresult_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftErrorResult_GNU_swift_error_result;
}
value
Val_clang_ext_swifterrorresult_spelling(enum clang_ext_SwiftErrorResult_spelling v)
{
switch (v) {
case clang_ext_SwiftErrorResult_GNU_swift_error_result: return Val_int(0);
case clang_ext_SwiftErrorResult_CXX11_clang_swift_error_result: return Val_int(1);
case clang_ext_SwiftErrorResult_C2x_clang_swift_error_result: return Val_int(2);
case clang_ext_SwiftErrorResult_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swifterrorresult_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftErrorResult_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftErrorResult_spelling result = clang_ext_SwiftErrorResult_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swifterrorresult_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftIndirectResult_spelling
Clang_ext_swiftindirectresult_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftIndirectResult_GNU_swift_indirect_result;
case 1: return clang_ext_SwiftIndirectResult_CXX11_clang_swift_indirect_result;
case 2: return clang_ext_SwiftIndirectResult_C2x_clang_swift_indirect_result;
case 3: return clang_ext_SwiftIndirectResult_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftindirectresult_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftIndirectResult_GNU_swift_indirect_result;
}
value
Val_clang_ext_swiftindirectresult_spelling(enum clang_ext_SwiftIndirectResult_spelling v)
{
switch (v) {
case clang_ext_SwiftIndirectResult_GNU_swift_indirect_result: return Val_int(0);
case clang_ext_SwiftIndirectResult_CXX11_clang_swift_indirect_result: return Val_int(1);
case clang_ext_SwiftIndirectResult_C2x_clang_swift_indirect_result: return Val_int(2);
case clang_ext_SwiftIndirectResult_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftindirectresult_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftIndirectResult_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftIndirectResult_spelling result = clang_ext_SwiftIndirectResult_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftindirectresult_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftNewType_spelling
Clang_ext_swiftnewtype_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftNewType_GNU_swift_newtype;
case 1: return clang_ext_SwiftNewType_GNU_swift_wrapper;
case 2: return clang_ext_SwiftNewType_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftnewtype_spelling_val: %d", Int_val(ocaml));
return clang_ext_SwiftNewType_GNU_swift_newtype;
}
value
Val_clang_ext_swiftnewtype_spelling(enum clang_ext_SwiftNewType_spelling v)
{
switch (v) {
case clang_ext_SwiftNewType_GNU_swift_newtype: return Val_int(0);
case clang_ext_SwiftNewType_GNU_swift_wrapper: return Val_int(1);
case clang_ext_SwiftNewType_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftnewtype_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftNewType_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftNewType_spelling result = clang_ext_SwiftNewType_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftnewtype_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_SysVABI_spelling
Clang_ext_sysvabi_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SysVABI_GNU_sysv_abi;
case 1: return clang_ext_SysVABI_CXX11_gnu_sysv_abi;
case 2: return clang_ext_SysVABI_C2x_gnu_sysv_abi;
case 3: return clang_ext_SysVABI_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_sysvabi_spelling_val: %d", Int_val(ocaml));
return clang_ext_SysVABI_GNU_sysv_abi;
}
value
Val_clang_ext_sysvabi_spelling(enum clang_ext_SysVABI_spelling v)
{
switch (v) {
case clang_ext_SysVABI_GNU_sysv_abi: return Val_int(0);
case clang_ext_SysVABI_CXX11_gnu_sysv_abi: return Val_int(1);
case clang_ext_SysVABI_C2x_gnu_sysv_abi: return Val_int(2);
case clang_ext_SysVABI_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_sysvabi_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SysVABI_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SysVABI_spelling result = clang_ext_SysVABI_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_sysvabi_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TLSModel_spelling
Clang_ext_tlsmodel_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TLSModel_GNU_tls_model;
case 1: return clang_ext_TLSModel_CXX11_gnu_tls_model;
case 2: return clang_ext_TLSModel_C2x_gnu_tls_model;
case 3: return clang_ext_TLSModel_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_tlsmodel_spelling_val: %d", Int_val(ocaml));
return clang_ext_TLSModel_GNU_tls_model;
}
value
Val_clang_ext_tlsmodel_spelling(enum clang_ext_TLSModel_spelling v)
{
switch (v) {
case clang_ext_TLSModel_GNU_tls_model: return Val_int(0);
case clang_ext_TLSModel_CXX11_gnu_tls_model: return Val_int(1);
case clang_ext_TLSModel_C2x_gnu_tls_model: return Val_int(2);
case clang_ext_TLSModel_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_tlsmodel_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TLSModel_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TLSModel_spelling result = clang_ext_TLSModel_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_tlsmodel_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Target_spelling
Clang_ext_target_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Target_GNU_target;
case 1: return clang_ext_Target_CXX11_gnu_target;
case 2: return clang_ext_Target_C2x_gnu_target;
case 3: return clang_ext_Target_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_target_spelling_val: %d", Int_val(ocaml));
return clang_ext_Target_GNU_target;
}
value
Val_clang_ext_target_spelling(enum clang_ext_Target_spelling v)
{
switch (v) {
case clang_ext_Target_GNU_target: return Val_int(0);
case clang_ext_Target_CXX11_gnu_target: return Val_int(1);
case clang_ext_Target_C2x_gnu_target: return Val_int(2);
case clang_ext_Target_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_target_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Target_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Target_spelling result = clang_ext_Target_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_target_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TargetClones_spelling
Clang_ext_targetclones_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TargetClones_GNU_target_clones;
case 1: return clang_ext_TargetClones_CXX11_gnu_target_clones;
case 2: return clang_ext_TargetClones_C2x_gnu_target_clones;
case 3: return clang_ext_TargetClones_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_targetclones_spelling_val: %d", Int_val(ocaml));
return clang_ext_TargetClones_GNU_target_clones;
}
value
Val_clang_ext_targetclones_spelling(enum clang_ext_TargetClones_spelling v)
{
switch (v) {
case clang_ext_TargetClones_GNU_target_clones: return Val_int(0);
case clang_ext_TargetClones_CXX11_gnu_target_clones: return Val_int(1);
case clang_ext_TargetClones_C2x_gnu_target_clones: return Val_int(2);
case clang_ext_TargetClones_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_targetclones_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TargetClones_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TargetClones_spelling result = clang_ext_TargetClones_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_targetclones_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TestTypestate_spelling
Clang_ext_testtypestate_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TestTypestate_GNU_test_typestate;
case 1: return clang_ext_TestTypestate_CXX11_clang_test_typestate;
case 2: return clang_ext_TestTypestate_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_testtypestate_spelling_val: %d", Int_val(ocaml));
return clang_ext_TestTypestate_GNU_test_typestate;
}
value
Val_clang_ext_testtypestate_spelling(enum clang_ext_TestTypestate_spelling v)
{
switch (v) {
case clang_ext_TestTypestate_GNU_test_typestate: return Val_int(0);
case clang_ext_TestTypestate_CXX11_clang_test_typestate: return Val_int(1);
case clang_ext_TestTypestate_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_testtypestate_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TestTypestate_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TestTypestate_spelling result = clang_ext_TestTypestate_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_testtypestate_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ThisCall_spelling
Clang_ext_thiscall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ThisCall_GNU_thiscall;
case 1: return clang_ext_ThisCall_CXX11_gnu_thiscall;
case 2: return clang_ext_ThisCall_C2x_gnu_thiscall;
case 3: return clang_ext_ThisCall_Keyword_thiscall;
case 4: return clang_ext_ThisCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_thiscall_spelling_val: %d", Int_val(ocaml));
return clang_ext_ThisCall_GNU_thiscall;
}
value
Val_clang_ext_thiscall_spelling(enum clang_ext_ThisCall_spelling v)
{
switch (v) {
case clang_ext_ThisCall_GNU_thiscall: return Val_int(0);
case clang_ext_ThisCall_CXX11_gnu_thiscall: return Val_int(1);
case clang_ext_ThisCall_C2x_gnu_thiscall: return Val_int(2);
case clang_ext_ThisCall_Keyword_thiscall: return Val_int(3);
case clang_ext_ThisCall_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_thiscall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ThisCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ThisCall_spelling result = clang_ext_ThisCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_thiscall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TransparentUnion_spelling
Clang_ext_transparentunion_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TransparentUnion_GNU_transparent_union;
case 1: return clang_ext_TransparentUnion_CXX11_gnu_transparent_union;
case 2: return clang_ext_TransparentUnion_C2x_gnu_transparent_union;
case 3: return clang_ext_TransparentUnion_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_transparentunion_spelling_val: %d", Int_val(ocaml));
return clang_ext_TransparentUnion_GNU_transparent_union;
}
value
Val_clang_ext_transparentunion_spelling(enum clang_ext_TransparentUnion_spelling v)
{
switch (v) {
case clang_ext_TransparentUnion_GNU_transparent_union: return Val_int(0);
case clang_ext_TransparentUnion_CXX11_gnu_transparent_union: return Val_int(1);
case clang_ext_TransparentUnion_C2x_gnu_transparent_union: return Val_int(2);
case clang_ext_TransparentUnion_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_transparentunion_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TransparentUnion_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TransparentUnion_spelling result = clang_ext_TransparentUnion_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_transparentunion_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TrivialABI_spelling
Clang_ext_trivialabi_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TrivialABI_GNU_trivial_abi;
case 1: return clang_ext_TrivialABI_CXX11_clang_trivial_abi;
case 2: return clang_ext_TrivialABI_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_trivialabi_spelling_val: %d", Int_val(ocaml));
return clang_ext_TrivialABI_GNU_trivial_abi;
}
value
Val_clang_ext_trivialabi_spelling(enum clang_ext_TrivialABI_spelling v)
{
switch (v) {
case clang_ext_TrivialABI_GNU_trivial_abi: return Val_int(0);
case clang_ext_TrivialABI_CXX11_clang_trivial_abi: return Val_int(1);
case clang_ext_TrivialABI_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_trivialabi_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TrivialABI_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TrivialABI_spelling result = clang_ext_TrivialABI_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_trivialabi_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TryAcquireCapability_spelling
Clang_ext_tryacquirecapability_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TryAcquireCapability_GNU_try_acquire_capability;
case 1: return clang_ext_TryAcquireCapability_CXX11_clang_try_acquire_capability;
case 2: return clang_ext_TryAcquireCapability_GNU_try_acquire_shared_capability;
case 3: return clang_ext_TryAcquireCapability_CXX11_clang_try_acquire_shared_capability;
case 4: return clang_ext_TryAcquireCapability_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_tryacquirecapability_spelling_val: %d", Int_val(ocaml));
return clang_ext_TryAcquireCapability_GNU_try_acquire_capability;
}
value
Val_clang_ext_tryacquirecapability_spelling(enum clang_ext_TryAcquireCapability_spelling v)
{
switch (v) {
case clang_ext_TryAcquireCapability_GNU_try_acquire_capability: return Val_int(0);
case clang_ext_TryAcquireCapability_CXX11_clang_try_acquire_capability: return Val_int(1);
case clang_ext_TryAcquireCapability_GNU_try_acquire_shared_capability: return Val_int(2);
case clang_ext_TryAcquireCapability_CXX11_clang_try_acquire_shared_capability: return Val_int(3);
case clang_ext_TryAcquireCapability_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_tryacquirecapability_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TryAcquireCapability_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TryAcquireCapability_spelling result = clang_ext_TryAcquireCapability_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_tryacquirecapability_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TypeTagForDatatype_spelling
Clang_ext_typetagfordatatype_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TypeTagForDatatype_GNU_type_tag_for_datatype;
case 1: return clang_ext_TypeTagForDatatype_CXX11_clang_type_tag_for_datatype;
case 2: return clang_ext_TypeTagForDatatype_C2x_clang_type_tag_for_datatype;
case 3: return clang_ext_TypeTagForDatatype_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_typetagfordatatype_spelling_val: %d", Int_val(ocaml));
return clang_ext_TypeTagForDatatype_GNU_type_tag_for_datatype;
}
value
Val_clang_ext_typetagfordatatype_spelling(enum clang_ext_TypeTagForDatatype_spelling v)
{
switch (v) {
case clang_ext_TypeTagForDatatype_GNU_type_tag_for_datatype: return Val_int(0);
case clang_ext_TypeTagForDatatype_CXX11_clang_type_tag_for_datatype: return Val_int(1);
case clang_ext_TypeTagForDatatype_C2x_clang_type_tag_for_datatype: return Val_int(2);
case clang_ext_TypeTagForDatatype_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_typetagfordatatype_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TypeTagForDatatype_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TypeTagForDatatype_spelling result = clang_ext_TypeTagForDatatype_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_typetagfordatatype_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_TypeVisibility_spelling
Clang_ext_typevisibility_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TypeVisibility_GNU_type_visibility;
case 1: return clang_ext_TypeVisibility_CXX11_clang_type_visibility;
case 2: return clang_ext_TypeVisibility_C2x_clang_type_visibility;
case 3: return clang_ext_TypeVisibility_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_typevisibility_spelling_val: %d", Int_val(ocaml));
return clang_ext_TypeVisibility_GNU_type_visibility;
}
value
Val_clang_ext_typevisibility_spelling(enum clang_ext_TypeVisibility_spelling v)
{
switch (v) {
case clang_ext_TypeVisibility_GNU_type_visibility: return Val_int(0);
case clang_ext_TypeVisibility_CXX11_clang_type_visibility: return Val_int(1);
case clang_ext_TypeVisibility_C2x_clang_type_visibility: return Val_int(2);
case clang_ext_TypeVisibility_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_typevisibility_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TypeVisibility_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TypeVisibility_spelling result = clang_ext_TypeVisibility_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_typevisibility_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Unavailable_spelling
Clang_ext_unavailable_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Unavailable_GNU_unavailable;
case 1: return clang_ext_Unavailable_CXX11_clang_unavailable;
case 2: return clang_ext_Unavailable_C2x_clang_unavailable;
case 3: return clang_ext_Unavailable_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_unavailable_spelling_val: %d", Int_val(ocaml));
return clang_ext_Unavailable_GNU_unavailable;
}
value
Val_clang_ext_unavailable_spelling(enum clang_ext_Unavailable_spelling v)
{
switch (v) {
case clang_ext_Unavailable_GNU_unavailable: return Val_int(0);
case clang_ext_Unavailable_CXX11_clang_unavailable: return Val_int(1);
case clang_ext_Unavailable_C2x_clang_unavailable: return Val_int(2);
case clang_ext_Unavailable_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_unavailable_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Unavailable_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Unavailable_spelling result = clang_ext_Unavailable_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_unavailable_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Uninitialized_spelling
Clang_ext_uninitialized_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Uninitialized_GNU_uninitialized;
case 1: return clang_ext_Uninitialized_CXX11_clang_uninitialized;
case 2: return clang_ext_Uninitialized_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_uninitialized_spelling_val: %d", Int_val(ocaml));
return clang_ext_Uninitialized_GNU_uninitialized;
}
value
Val_clang_ext_uninitialized_spelling(enum clang_ext_Uninitialized_spelling v)
{
switch (v) {
case clang_ext_Uninitialized_GNU_uninitialized: return Val_int(0);
case clang_ext_Uninitialized_CXX11_clang_uninitialized: return Val_int(1);
case clang_ext_Uninitialized_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_uninitialized_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Uninitialized_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Uninitialized_spelling result = clang_ext_Uninitialized_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_uninitialized_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Unlikely_spelling
Clang_ext_unlikely_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Unlikely_CXX11_unlikely;
case 1: return clang_ext_Unlikely_C2x_clang_unlikely;
case 2: return clang_ext_Unlikely_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_unlikely_spelling_val: %d", Int_val(ocaml));
return clang_ext_Unlikely_CXX11_unlikely;
}
value
Val_clang_ext_unlikely_spelling(enum clang_ext_Unlikely_spelling v)
{
switch (v) {
case clang_ext_Unlikely_CXX11_unlikely: return Val_int(0);
case clang_ext_Unlikely_C2x_clang_unlikely: return Val_int(1);
case clang_ext_Unlikely_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_unlikely_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Unlikely_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Unlikely_spelling result = clang_ext_Unlikely_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_unlikely_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Unused_spelling
Clang_ext_unused_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Unused_CXX11_maybe_unused;
case 1: return clang_ext_Unused_GNU_unused;
case 2: return clang_ext_Unused_CXX11_gnu_unused;
case 3: return clang_ext_Unused_C2x_gnu_unused;
case 4: return clang_ext_Unused_C2x_maybe_unused;
case 5: return clang_ext_Unused_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_unused_spelling_val: %d", Int_val(ocaml));
return clang_ext_Unused_CXX11_maybe_unused;
}
value
Val_clang_ext_unused_spelling(enum clang_ext_Unused_spelling v)
{
switch (v) {
case clang_ext_Unused_CXX11_maybe_unused: return Val_int(0);
case clang_ext_Unused_GNU_unused: return Val_int(1);
case clang_ext_Unused_CXX11_gnu_unused: return Val_int(2);
case clang_ext_Unused_C2x_gnu_unused: return Val_int(3);
case clang_ext_Unused_C2x_maybe_unused: return Val_int(4);
case clang_ext_Unused_SpellingNotCalculated: return Val_int(5);
}
caml_failwith_fmt("invalid value for Val_clang_ext_unused_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Unused_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Unused_spelling result = clang_ext_Unused_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_unused_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_UseHandle_spelling
Clang_ext_usehandle_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_UseHandle_GNU_use_handle;
case 1: return clang_ext_UseHandle_CXX11_clang_use_handle;
case 2: return clang_ext_UseHandle_C2x_clang_use_handle;
case 3: return clang_ext_UseHandle_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_usehandle_spelling_val: %d", Int_val(ocaml));
return clang_ext_UseHandle_GNU_use_handle;
}
value
Val_clang_ext_usehandle_spelling(enum clang_ext_UseHandle_spelling v)
{
switch (v) {
case clang_ext_UseHandle_GNU_use_handle: return Val_int(0);
case clang_ext_UseHandle_CXX11_clang_use_handle: return Val_int(1);
case clang_ext_UseHandle_C2x_clang_use_handle: return Val_int(2);
case clang_ext_UseHandle_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_usehandle_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_UseHandle_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_UseHandle_spelling result = clang_ext_UseHandle_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_usehandle_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Used_spelling
Clang_ext_used_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Used_GNU_used;
case 1: return clang_ext_Used_CXX11_gnu_used;
case 2: return clang_ext_Used_C2x_gnu_used;
case 3: return clang_ext_Used_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_used_spelling_val: %d", Int_val(ocaml));
return clang_ext_Used_GNU_used;
}
value
Val_clang_ext_used_spelling(enum clang_ext_Used_spelling v)
{
switch (v) {
case clang_ext_Used_GNU_used: return Val_int(0);
case clang_ext_Used_CXX11_gnu_used: return Val_int(1);
case clang_ext_Used_C2x_gnu_used: return Val_int(2);
case clang_ext_Used_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_used_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Used_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Used_spelling result = clang_ext_Used_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_used_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_UsingIfExists_spelling
Clang_ext_usingifexists_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_UsingIfExists_GNU_using_if_exists;
case 1: return clang_ext_UsingIfExists_CXX11_clang_using_if_exists;
case 2: return clang_ext_UsingIfExists_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_usingifexists_spelling_val: %d", Int_val(ocaml));
return clang_ext_UsingIfExists_GNU_using_if_exists;
}
value
Val_clang_ext_usingifexists_spelling(enum clang_ext_UsingIfExists_spelling v)
{
switch (v) {
case clang_ext_UsingIfExists_GNU_using_if_exists: return Val_int(0);
case clang_ext_UsingIfExists_CXX11_clang_using_if_exists: return Val_int(1);
case clang_ext_UsingIfExists_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_usingifexists_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_UsingIfExists_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_UsingIfExists_spelling result = clang_ext_UsingIfExists_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_usingifexists_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Uuid_spelling
Clang_ext_uuid_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Uuid_Declspec_uuid;
case 1: return clang_ext_Uuid_Microsoft_uuid;
case 2: return clang_ext_Uuid_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_uuid_spelling_val: %d", Int_val(ocaml));
return clang_ext_Uuid_Declspec_uuid;
}
value
Val_clang_ext_uuid_spelling(enum clang_ext_Uuid_spelling v)
{
switch (v) {
case clang_ext_Uuid_Declspec_uuid: return Val_int(0);
case clang_ext_Uuid_Microsoft_uuid: return Val_int(1);
case clang_ext_Uuid_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_uuid_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Uuid_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Uuid_spelling result = clang_ext_Uuid_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_uuid_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_VecReturn_spelling
Clang_ext_vecreturn_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_VecReturn_GNU_vecreturn;
case 1: return clang_ext_VecReturn_CXX11_clang_vecreturn;
case 2: return clang_ext_VecReturn_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_vecreturn_spelling_val: %d", Int_val(ocaml));
return clang_ext_VecReturn_GNU_vecreturn;
}
value
Val_clang_ext_vecreturn_spelling(enum clang_ext_VecReturn_spelling v)
{
switch (v) {
case clang_ext_VecReturn_GNU_vecreturn: return Val_int(0);
case clang_ext_VecReturn_CXX11_clang_vecreturn: return Val_int(1);
case clang_ext_VecReturn_SpellingNotCalculated: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_vecreturn_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_VecReturn_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_VecReturn_spelling result = clang_ext_VecReturn_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_vecreturn_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_VectorCall_spelling
Clang_ext_vectorcall_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_VectorCall_GNU_vectorcall;
case 1: return clang_ext_VectorCall_CXX11_clang_vectorcall;
case 2: return clang_ext_VectorCall_C2x_clang_vectorcall;
case 3: return clang_ext_VectorCall_Keyword_vectorcall;
case 4: return clang_ext_VectorCall_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_vectorcall_spelling_val: %d", Int_val(ocaml));
return clang_ext_VectorCall_GNU_vectorcall;
}
value
Val_clang_ext_vectorcall_spelling(enum clang_ext_VectorCall_spelling v)
{
switch (v) {
case clang_ext_VectorCall_GNU_vectorcall: return Val_int(0);
case clang_ext_VectorCall_CXX11_clang_vectorcall: return Val_int(1);
case clang_ext_VectorCall_C2x_clang_vectorcall: return Val_int(2);
case clang_ext_VectorCall_Keyword_vectorcall: return Val_int(3);
case clang_ext_VectorCall_SpellingNotCalculated: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_vectorcall_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_VectorCall_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_VectorCall_spelling result = clang_ext_VectorCall_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_vectorcall_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Visibility_spelling
Clang_ext_visibility_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Visibility_GNU_visibility;
case 1: return clang_ext_Visibility_CXX11_gnu_visibility;
case 2: return clang_ext_Visibility_C2x_gnu_visibility;
case 3: return clang_ext_Visibility_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_visibility_spelling_val: %d", Int_val(ocaml));
return clang_ext_Visibility_GNU_visibility;
}
value
Val_clang_ext_visibility_spelling(enum clang_ext_Visibility_spelling v)
{
switch (v) {
case clang_ext_Visibility_GNU_visibility: return Val_int(0);
case clang_ext_Visibility_CXX11_gnu_visibility: return Val_int(1);
case clang_ext_Visibility_C2x_gnu_visibility: return Val_int(2);
case clang_ext_Visibility_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_visibility_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Visibility_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Visibility_spelling result = clang_ext_Visibility_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_visibility_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_WarnUnused_spelling
Clang_ext_warnunused_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_WarnUnused_GNU_warn_unused;
case 1: return clang_ext_WarnUnused_CXX11_gnu_warn_unused;
case 2: return clang_ext_WarnUnused_C2x_gnu_warn_unused;
case 3: return clang_ext_WarnUnused_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_warnunused_spelling_val: %d", Int_val(ocaml));
return clang_ext_WarnUnused_GNU_warn_unused;
}
value
Val_clang_ext_warnunused_spelling(enum clang_ext_WarnUnused_spelling v)
{
switch (v) {
case clang_ext_WarnUnused_GNU_warn_unused: return Val_int(0);
case clang_ext_WarnUnused_CXX11_gnu_warn_unused: return Val_int(1);
case clang_ext_WarnUnused_C2x_gnu_warn_unused: return Val_int(2);
case clang_ext_WarnUnused_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_warnunused_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_WarnUnused_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_WarnUnused_spelling result = clang_ext_WarnUnused_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_warnunused_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_WarnUnusedResult_spelling
Clang_ext_warnunusedresult_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_WarnUnusedResult_CXX11_nodiscard;
case 1: return clang_ext_WarnUnusedResult_C2x_nodiscard;
case 2: return clang_ext_WarnUnusedResult_CXX11_clang_warn_unused_result;
case 3: return clang_ext_WarnUnusedResult_GNU_warn_unused_result;
case 4: return clang_ext_WarnUnusedResult_CXX11_gnu_warn_unused_result;
case 5: return clang_ext_WarnUnusedResult_C2x_gnu_warn_unused_result;
case 6: return clang_ext_WarnUnusedResult_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_warnunusedresult_spelling_val: %d", Int_val(ocaml));
return clang_ext_WarnUnusedResult_CXX11_nodiscard;
}
value
Val_clang_ext_warnunusedresult_spelling(enum clang_ext_WarnUnusedResult_spelling v)
{
switch (v) {
case clang_ext_WarnUnusedResult_CXX11_nodiscard: return Val_int(0);
case clang_ext_WarnUnusedResult_C2x_nodiscard: return Val_int(1);
case clang_ext_WarnUnusedResult_CXX11_clang_warn_unused_result: return Val_int(2);
case clang_ext_WarnUnusedResult_GNU_warn_unused_result: return Val_int(3);
case clang_ext_WarnUnusedResult_CXX11_gnu_warn_unused_result: return Val_int(4);
case clang_ext_WarnUnusedResult_C2x_gnu_warn_unused_result: return Val_int(5);
case clang_ext_WarnUnusedResult_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_warnunusedresult_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_WarnUnusedResult_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_WarnUnusedResult_spelling result = clang_ext_WarnUnusedResult_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_warnunusedresult_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_Weak_spelling
Clang_ext_weak_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_Weak_GNU_weak;
case 1: return clang_ext_Weak_CXX11_gnu_weak;
case 2: return clang_ext_Weak_C2x_gnu_weak;
case 3: return clang_ext_Weak_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_weak_spelling_val: %d", Int_val(ocaml));
return clang_ext_Weak_GNU_weak;
}
value
Val_clang_ext_weak_spelling(enum clang_ext_Weak_spelling v)
{
switch (v) {
case clang_ext_Weak_GNU_weak: return Val_int(0);
case clang_ext_Weak_CXX11_gnu_weak: return Val_int(1);
case clang_ext_Weak_C2x_gnu_weak: return Val_int(2);
case clang_ext_Weak_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_weak_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_Weak_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_Weak_spelling result = clang_ext_Weak_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_weak_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_WeakImport_spelling
Clang_ext_weakimport_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_WeakImport_GNU_weak_import;
case 1: return clang_ext_WeakImport_CXX11_clang_weak_import;
case 2: return clang_ext_WeakImport_C2x_clang_weak_import;
case 3: return clang_ext_WeakImport_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_weakimport_spelling_val: %d", Int_val(ocaml));
return clang_ext_WeakImport_GNU_weak_import;
}
value
Val_clang_ext_weakimport_spelling(enum clang_ext_WeakImport_spelling v)
{
switch (v) {
case clang_ext_WeakImport_GNU_weak_import: return Val_int(0);
case clang_ext_WeakImport_CXX11_clang_weak_import: return Val_int(1);
case clang_ext_WeakImport_C2x_clang_weak_import: return Val_int(2);
case clang_ext_WeakImport_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_weakimport_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_WeakImport_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_WeakImport_spelling result = clang_ext_WeakImport_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_weakimport_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_WeakRef_spelling
Clang_ext_weakref_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_WeakRef_GNU_weakref;
case 1: return clang_ext_WeakRef_CXX11_gnu_weakref;
case 2: return clang_ext_WeakRef_C2x_gnu_weakref;
case 3: return clang_ext_WeakRef_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_weakref_spelling_val: %d", Int_val(ocaml));
return clang_ext_WeakRef_GNU_weakref;
}
value
Val_clang_ext_weakref_spelling(enum clang_ext_WeakRef_spelling v)
{
switch (v) {
case clang_ext_WeakRef_GNU_weakref: return Val_int(0);
case clang_ext_WeakRef_CXX11_gnu_weakref: return Val_int(1);
case clang_ext_WeakRef_C2x_gnu_weakref: return Val_int(2);
case clang_ext_WeakRef_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_weakref_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_WeakRef_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_WeakRef_spelling result = clang_ext_WeakRef_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_weakref_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_WebAssemblyExportName_spelling
Clang_ext_webassemblyexportname_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_WebAssemblyExportName_GNU_export_name;
case 1: return clang_ext_WebAssemblyExportName_CXX11_clang_export_name;
case 2: return clang_ext_WebAssemblyExportName_C2x_clang_export_name;
case 3: return clang_ext_WebAssemblyExportName_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_webassemblyexportname_spelling_val: %d", Int_val(ocaml));
return clang_ext_WebAssemblyExportName_GNU_export_name;
}
value
Val_clang_ext_webassemblyexportname_spelling(enum clang_ext_WebAssemblyExportName_spelling v)
{
switch (v) {
case clang_ext_WebAssemblyExportName_GNU_export_name: return Val_int(0);
case clang_ext_WebAssemblyExportName_CXX11_clang_export_name: return Val_int(1);
case clang_ext_WebAssemblyExportName_C2x_clang_export_name: return Val_int(2);
case clang_ext_WebAssemblyExportName_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_webassemblyexportname_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_WebAssemblyExportName_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_WebAssemblyExportName_spelling result = clang_ext_WebAssemblyExportName_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_webassemblyexportname_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_WebAssemblyImportModule_spelling
Clang_ext_webassemblyimportmodule_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_WebAssemblyImportModule_GNU_import_module;
case 1: return clang_ext_WebAssemblyImportModule_CXX11_clang_import_module;
case 2: return clang_ext_WebAssemblyImportModule_C2x_clang_import_module;
case 3: return clang_ext_WebAssemblyImportModule_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_webassemblyimportmodule_spelling_val: %d", Int_val(ocaml));
return clang_ext_WebAssemblyImportModule_GNU_import_module;
}
value
Val_clang_ext_webassemblyimportmodule_spelling(enum clang_ext_WebAssemblyImportModule_spelling v)
{
switch (v) {
case clang_ext_WebAssemblyImportModule_GNU_import_module: return Val_int(0);
case clang_ext_WebAssemblyImportModule_CXX11_clang_import_module: return Val_int(1);
case clang_ext_WebAssemblyImportModule_C2x_clang_import_module: return Val_int(2);
case clang_ext_WebAssemblyImportModule_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_webassemblyimportmodule_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_WebAssemblyImportModule_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_WebAssemblyImportModule_spelling result = clang_ext_WebAssemblyImportModule_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_webassemblyimportmodule_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_WebAssemblyImportName_spelling
Clang_ext_webassemblyimportname_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_WebAssemblyImportName_GNU_import_name;
case 1: return clang_ext_WebAssemblyImportName_CXX11_clang_import_name;
case 2: return clang_ext_WebAssemblyImportName_C2x_clang_import_name;
case 3: return clang_ext_WebAssemblyImportName_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_webassemblyimportname_spelling_val: %d", Int_val(ocaml));
return clang_ext_WebAssemblyImportName_GNU_import_name;
}
value
Val_clang_ext_webassemblyimportname_spelling(enum clang_ext_WebAssemblyImportName_spelling v)
{
switch (v) {
case clang_ext_WebAssemblyImportName_GNU_import_name: return Val_int(0);
case clang_ext_WebAssemblyImportName_CXX11_clang_import_name: return Val_int(1);
case clang_ext_WebAssemblyImportName_C2x_clang_import_name: return Val_int(2);
case clang_ext_WebAssemblyImportName_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_webassemblyimportname_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_WebAssemblyImportName_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_WebAssemblyImportName_spelling result = clang_ext_WebAssemblyImportName_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_webassemblyimportname_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_X86ForceAlignArgPointer_spelling
Clang_ext_x86forcealignargpointer_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_X86ForceAlignArgPointer_GNU_force_align_arg_pointer;
case 1: return clang_ext_X86ForceAlignArgPointer_CXX11_gnu_force_align_arg_pointer;
case 2: return clang_ext_X86ForceAlignArgPointer_C2x_gnu_force_align_arg_pointer;
case 3: return clang_ext_X86ForceAlignArgPointer_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_x86forcealignargpointer_spelling_val: %d", Int_val(ocaml));
return clang_ext_X86ForceAlignArgPointer_GNU_force_align_arg_pointer;
}
value
Val_clang_ext_x86forcealignargpointer_spelling(enum clang_ext_X86ForceAlignArgPointer_spelling v)
{
switch (v) {
case clang_ext_X86ForceAlignArgPointer_GNU_force_align_arg_pointer: return Val_int(0);
case clang_ext_X86ForceAlignArgPointer_CXX11_gnu_force_align_arg_pointer: return Val_int(1);
case clang_ext_X86ForceAlignArgPointer_C2x_gnu_force_align_arg_pointer: return Val_int(2);
case clang_ext_X86ForceAlignArgPointer_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_x86forcealignargpointer_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_X86ForceAlignArgPointer_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_X86ForceAlignArgPointer_spelling result = clang_ext_X86ForceAlignArgPointer_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_x86forcealignargpointer_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_XRayInstrument_spelling
Clang_ext_xrayinstrument_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_XRayInstrument_GNU_xray_always_instrument;
case 1: return clang_ext_XRayInstrument_CXX11_clang_xray_always_instrument;
case 2: return clang_ext_XRayInstrument_C2x_clang_xray_always_instrument;
case 3: return clang_ext_XRayInstrument_GNU_xray_never_instrument;
case 4: return clang_ext_XRayInstrument_CXX11_clang_xray_never_instrument;
case 5: return clang_ext_XRayInstrument_C2x_clang_xray_never_instrument;
case 6: return clang_ext_XRayInstrument_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_xrayinstrument_spelling_val: %d", Int_val(ocaml));
return clang_ext_XRayInstrument_GNU_xray_always_instrument;
}
value
Val_clang_ext_xrayinstrument_spelling(enum clang_ext_XRayInstrument_spelling v)
{
switch (v) {
case clang_ext_XRayInstrument_GNU_xray_always_instrument: return Val_int(0);
case clang_ext_XRayInstrument_CXX11_clang_xray_always_instrument: return Val_int(1);
case clang_ext_XRayInstrument_C2x_clang_xray_always_instrument: return Val_int(2);
case clang_ext_XRayInstrument_GNU_xray_never_instrument: return Val_int(3);
case clang_ext_XRayInstrument_CXX11_clang_xray_never_instrument: return Val_int(4);
case clang_ext_XRayInstrument_C2x_clang_xray_never_instrument: return Val_int(5);
case clang_ext_XRayInstrument_SpellingNotCalculated: return Val_int(6);
}
caml_failwith_fmt("invalid value for Val_clang_ext_xrayinstrument_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_XRayInstrument_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_XRayInstrument_spelling result = clang_ext_XRayInstrument_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_xrayinstrument_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_XRayLogArgs_spelling
Clang_ext_xraylogargs_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_XRayLogArgs_GNU_xray_log_args;
case 1: return clang_ext_XRayLogArgs_CXX11_clang_xray_log_args;
case 2: return clang_ext_XRayLogArgs_C2x_clang_xray_log_args;
case 3: return clang_ext_XRayLogArgs_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_xraylogargs_spelling_val: %d", Int_val(ocaml));
return clang_ext_XRayLogArgs_GNU_xray_log_args;
}
value
Val_clang_ext_xraylogargs_spelling(enum clang_ext_XRayLogArgs_spelling v)
{
switch (v) {
case clang_ext_XRayLogArgs_GNU_xray_log_args: return Val_int(0);
case clang_ext_XRayLogArgs_CXX11_clang_xray_log_args: return Val_int(1);
case clang_ext_XRayLogArgs_C2x_clang_xray_log_args: return Val_int(2);
case clang_ext_XRayLogArgs_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_xraylogargs_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_XRayLogArgs_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_XRayLogArgs_spelling result = clang_ext_XRayLogArgs_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_xraylogargs_spelling(result);
CAMLreturn(data);
}
}
enum clang_ext_ZeroCallUsedRegs_spelling
Clang_ext_zerocallusedregs_spelling_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ZeroCallUsedRegs_GNU_zero_call_used_regs;
case 1: return clang_ext_ZeroCallUsedRegs_CXX11_gnu_zero_call_used_regs;
case 2: return clang_ext_ZeroCallUsedRegs_C2x_gnu_zero_call_used_regs;
case 3: return clang_ext_ZeroCallUsedRegs_SpellingNotCalculated;
}
caml_failwith_fmt("invalid value for Clang_ext_zerocallusedregs_spelling_val: %d", Int_val(ocaml));
return clang_ext_ZeroCallUsedRegs_GNU_zero_call_used_regs;
}
value
Val_clang_ext_zerocallusedregs_spelling(enum clang_ext_ZeroCallUsedRegs_spelling v)
{
switch (v) {
case clang_ext_ZeroCallUsedRegs_GNU_zero_call_used_regs: return Val_int(0);
case clang_ext_ZeroCallUsedRegs_CXX11_gnu_zero_call_used_regs: return Val_int(1);
case clang_ext_ZeroCallUsedRegs_C2x_gnu_zero_call_used_regs: return Val_int(2);
case clang_ext_ZeroCallUsedRegs_SpellingNotCalculated: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_zerocallusedregs_spelling: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ZeroCallUsedRegs_getSpelling_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ZeroCallUsedRegs_spelling result = clang_ext_ZeroCallUsedRegs_getSpelling(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_zerocallusedregs_spelling(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getUniforms_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareSimdDeclAttr_getUniforms_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_ReturnTypestateAttr_ConsumedState
Clang_ext_returntypestateattr_consumedstate_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ReturnTypestateAttr_ConsumedState_Unknown;
case 1: return clang_ext_ReturnTypestateAttr_ConsumedState_Consumed;
case 2: return clang_ext_ReturnTypestateAttr_ConsumedState_Unconsumed;
}
caml_failwith_fmt("invalid value for Clang_ext_returntypestateattr_consumedstate_val: %d", Int_val(ocaml));
return clang_ext_ReturnTypestateAttr_ConsumedState_Unknown;
}
value
Val_clang_ext_returntypestateattr_consumedstate(enum clang_ext_ReturnTypestateAttr_ConsumedState v)
{
switch (v) {
case clang_ext_ReturnTypestateAttr_ConsumedState_Unknown: return Val_int(0);
case clang_ext_ReturnTypestateAttr_ConsumedState_Consumed: return Val_int(1);
case clang_ext_ReturnTypestateAttr_ConsumedState_Unconsumed: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_returntypestateattr_consumedstate: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ReturnTypestateAttr_getState_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ReturnTypestateAttr_ConsumedState result = clang_ext_ReturnTypestateAttr_getState(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_returntypestateattr_consumedstate(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getAliaseeLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getAliaseeLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ObjCRuntimeNameAttr_getMetadataName_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ObjCRuntimeNameAttr_getMetadataName(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftErrorAttr_ConventionKind
Clang_ext_swifterrorattr_conventionkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftErrorAttr_ConventionKind_None;
case 1: return clang_ext_SwiftErrorAttr_ConventionKind_NonNullError;
case 2: return clang_ext_SwiftErrorAttr_ConventionKind_NullResult;
case 3: return clang_ext_SwiftErrorAttr_ConventionKind_ZeroResult;
case 4: return clang_ext_SwiftErrorAttr_ConventionKind_NonZeroResult;
}
caml_failwith_fmt("invalid value for Clang_ext_swifterrorattr_conventionkind_val: %d", Int_val(ocaml));
return clang_ext_SwiftErrorAttr_ConventionKind_None;
}
value
Val_clang_ext_swifterrorattr_conventionkind(enum clang_ext_SwiftErrorAttr_ConventionKind v)
{
switch (v) {
case clang_ext_SwiftErrorAttr_ConventionKind_None: return Val_int(0);
case clang_ext_SwiftErrorAttr_ConventionKind_NonNullError: return Val_int(1);
case clang_ext_SwiftErrorAttr_ConventionKind_NullResult: return Val_int(2);
case clang_ext_SwiftErrorAttr_ConventionKind_ZeroResult: return Val_int(3);
case clang_ext_SwiftErrorAttr_ConventionKind_NonZeroResult: return Val_int(4);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swifterrorattr_conventionkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftErrorAttr_getConvention_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftErrorAttr_ConventionKind result = clang_ext_SwiftErrorAttr_getConvention(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swifterrorattr_conventionkind(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftAsyncErrorAttr_ConventionKind
Clang_ext_swiftasyncerrorattr_conventionkind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftAsyncErrorAttr_ConventionKind_None;
case 1: return clang_ext_SwiftAsyncErrorAttr_ConventionKind_NonNullError;
case 2: return clang_ext_SwiftAsyncErrorAttr_ConventionKind_ZeroArgument;
case 3: return clang_ext_SwiftAsyncErrorAttr_ConventionKind_NonZeroArgument;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftasyncerrorattr_conventionkind_val: %d", Int_val(ocaml));
return clang_ext_SwiftAsyncErrorAttr_ConventionKind_None;
}
value
Val_clang_ext_swiftasyncerrorattr_conventionkind(enum clang_ext_SwiftAsyncErrorAttr_ConventionKind v)
{
switch (v) {
case clang_ext_SwiftAsyncErrorAttr_ConventionKind_None: return Val_int(0);
case clang_ext_SwiftAsyncErrorAttr_ConventionKind_NonNullError: return Val_int(1);
case clang_ext_SwiftAsyncErrorAttr_ConventionKind_ZeroArgument: return Val_int(2);
case clang_ext_SwiftAsyncErrorAttr_ConventionKind_NonZeroArgument: return Val_int(3);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftasyncerrorattr_conventionkind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftAsyncErrorAttr_getConvention_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftAsyncErrorAttr_ConventionKind result = clang_ext_SwiftAsyncErrorAttr_getConvention(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftasyncerrorattr_conventionkind(result);
CAMLreturn(data);
}
}
void
clang_ext_Attrs_getDelayedArgs_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_Attrs_getDelayedArgs_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_Attrs_getDelayedArgs(cursor, clang_ext_Attrs_getDelayedArgs_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_IFuncAttr_getResolver_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_IFuncAttr_getResolver(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PatchableFunctionEntryAttr_getOffset_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_PatchableFunctionEntryAttr_getOffset(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AssumeAlignedAttr_getOffset_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_AssumeAlignedAttr_getOffset(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_BTFTypeTagAttr_getBTFTypeTagLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_BTFTypeTagAttr_getBTFTypeTagLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_WebAssemblyImportNameAttr_getImportNameLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_WebAssemblyImportNameAttr_getImportNameLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SentinelAttr_getSentinel_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_SentinelAttr_getSentinel(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getSuccessValue_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_Attrs_getSuccessValue(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getCpus_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getCpus_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TLSModelAttr_getModelLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_TLSModelAttr_getModelLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_ParamTypestateAttr_ConsumedState
Clang_ext_paramtypestateattr_consumedstate_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ParamTypestateAttr_ConsumedState_Unknown;
case 1: return clang_ext_ParamTypestateAttr_ConsumedState_Consumed;
case 2: return clang_ext_ParamTypestateAttr_ConsumedState_Unconsumed;
}
caml_failwith_fmt("invalid value for Clang_ext_paramtypestateattr_consumedstate_val: %d", Int_val(ocaml));
return clang_ext_ParamTypestateAttr_ConsumedState_Unknown;
}
value
Val_clang_ext_paramtypestateattr_consumedstate(enum clang_ext_ParamTypestateAttr_ConsumedState v)
{
switch (v) {
case clang_ext_ParamTypestateAttr_ConsumedState_Unknown: return Val_int(0);
case clang_ext_ParamTypestateAttr_ConsumedState_Consumed: return Val_int(1);
case clang_ext_ParamTypestateAttr_ConsumedState_Unconsumed: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_paramtypestateattr_consumedstate: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ParamTypestateAttr_getParamState_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ParamTypestateAttr_ConsumedState result = clang_ext_ParamTypestateAttr_getParamState(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_paramtypestateattr_consumedstate(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExternalSourceSymbolAttr_getGeneratedDeclaration_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_ExternalSourceSymbolAttr_getGeneratedDeclaration(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
void
clang_ext_SuppressAttr_getDiagnosticIdentifiers_callback_value_callback(CXString arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_copy_string(safe_string(clang_getCString(arg0)));
clang_disposeString(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_SuppressAttr_getDiagnosticIdentifiers_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_SuppressAttr_getDiagnosticIdentifiers(cursor, clang_ext_SuppressAttr_getDiagnosticIdentifiers_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_Attrs_getDerefType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_Attrs_getDerefType(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_FunctionReturnThunksAttr_Kind
Clang_ext_functionreturnthunksattr_kind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_FunctionReturnThunksAttr_Kind_Keep;
case 1: return clang_ext_FunctionReturnThunksAttr_Kind_Extern;
}
caml_failwith_fmt("invalid value for Clang_ext_functionreturnthunksattr_kind_val: %d", Int_val(ocaml));
return clang_ext_FunctionReturnThunksAttr_Kind_Keep;
}
value
Val_clang_ext_functionreturnthunksattr_kind(enum clang_ext_FunctionReturnThunksAttr_Kind v)
{
switch (v) {
case clang_ext_FunctionReturnThunksAttr_Kind_Keep: return Val_int(0);
case clang_ext_FunctionReturnThunksAttr_Kind_Extern: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_functionreturnthunksattr_kind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_FunctionReturnThunksAttr_getThunkType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_FunctionReturnThunksAttr_Kind result = clang_ext_FunctionReturnThunksAttr_getThunkType(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_functionreturnthunksattr_kind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNeedDevicePtr_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareVariantAttr_getAdjustArgsNeedDevicePtr_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeTagForDatatypeAttr_getMatchingCType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_TypeTagForDatatypeAttr_getMatchingCType(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getAnnotationLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getAnnotationLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_LayoutVersionAttr_getVersion_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_LayoutVersionAttr_getVersion(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SentinelAttr_getNullPos_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_SentinelAttr_getNullPos(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareSimdDeclAttr_getAligneds_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getAligneds_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareSimdDeclAttr_getAligneds(cursor, clang_ext_OMPDeclareSimdDeclAttr_getAligneds_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_SwiftAsyncAttr_getCompletionHandlerIndex_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_SwiftAsyncAttr_getCompletionHandlerIndex(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getArgs_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getArgs_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CUDALaunchBoundsAttr_getMinBlocks_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_CUDALaunchBoundsAttr_getMinBlocks(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_BTFDeclTagAttr_getBTFDeclTagLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_BTFDeclTagAttr_getBTFDeclTagLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SwiftBridgeAttr_getSwiftTypeLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_SwiftBridgeAttr_getSwiftTypeLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExternalSourceSymbolAttr_getDefinedInLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_ExternalSourceSymbolAttr_getDefinedInLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_HLSLShaderAttr_ShaderType
Clang_ext_hlslshaderattr_shadertype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_HLSLShaderAttr_ShaderType_Pixel;
case 1: return clang_ext_HLSLShaderAttr_ShaderType_Vertex;
case 2: return clang_ext_HLSLShaderAttr_ShaderType_Geometry;
case 3: return clang_ext_HLSLShaderAttr_ShaderType_Hull;
case 4: return clang_ext_HLSLShaderAttr_ShaderType_Domain;
case 5: return clang_ext_HLSLShaderAttr_ShaderType_Compute;
case 6: return clang_ext_HLSLShaderAttr_ShaderType_RayGeneration;
case 7: return clang_ext_HLSLShaderAttr_ShaderType_Intersection;
case 8: return clang_ext_HLSLShaderAttr_ShaderType_AnyHit;
case 9: return clang_ext_HLSLShaderAttr_ShaderType_ClosestHit;
case 10: return clang_ext_HLSLShaderAttr_ShaderType_Miss;
case 11: return clang_ext_HLSLShaderAttr_ShaderType_Callable;
case 12: return clang_ext_HLSLShaderAttr_ShaderType_Mesh;
case 13: return clang_ext_HLSLShaderAttr_ShaderType_Amplification;
}
caml_failwith_fmt("invalid value for Clang_ext_hlslshaderattr_shadertype_val: %d", Int_val(ocaml));
return clang_ext_HLSLShaderAttr_ShaderType_Pixel;
}
value
Val_clang_ext_hlslshaderattr_shadertype(enum clang_ext_HLSLShaderAttr_ShaderType v)
{
switch (v) {
case clang_ext_HLSLShaderAttr_ShaderType_Pixel: return Val_int(0);
case clang_ext_HLSLShaderAttr_ShaderType_Vertex: return Val_int(1);
case clang_ext_HLSLShaderAttr_ShaderType_Geometry: return Val_int(2);
case clang_ext_HLSLShaderAttr_ShaderType_Hull: return Val_int(3);
case clang_ext_HLSLShaderAttr_ShaderType_Domain: return Val_int(4);
case clang_ext_HLSLShaderAttr_ShaderType_Compute: return Val_int(5);
case clang_ext_HLSLShaderAttr_ShaderType_RayGeneration: return Val_int(6);
case clang_ext_HLSLShaderAttr_ShaderType_Intersection: return Val_int(7);
case clang_ext_HLSLShaderAttr_ShaderType_AnyHit: return Val_int(8);
case clang_ext_HLSLShaderAttr_ShaderType_ClosestHit: return Val_int(9);
case clang_ext_HLSLShaderAttr_ShaderType_Miss: return Val_int(10);
case clang_ext_HLSLShaderAttr_ShaderType_Callable: return Val_int(11);
case clang_ext_HLSLShaderAttr_ShaderType_Mesh: return Val_int(12);
case clang_ext_HLSLShaderAttr_ShaderType_Amplification: return Val_int(13);
}
caml_failwith_fmt("invalid value for Val_clang_ext_hlslshaderattr_shadertype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_HLSLShaderAttr_getType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_HLSLShaderAttr_ShaderType result = clang_ext_HLSLShaderAttr_getType(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_hlslshaderattr_shadertype(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FormatAttr_getType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_FormatAttr_getType(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PassObjectSizeAttr_getType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_PassObjectSizeAttr_getType(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_BlocksAttr_BlockType
Clang_ext_blocksattr_blocktype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_BlocksAttr_BlockType_ByRef;
}
caml_failwith_fmt("invalid value for Clang_ext_blocksattr_blocktype_val: %d", Int_val(ocaml));
return clang_ext_BlocksAttr_BlockType_ByRef;
}
value
Val_clang_ext_blocksattr_blocktype(enum clang_ext_BlocksAttr_BlockType v)
{
switch (v) {
case clang_ext_BlocksAttr_BlockType_ByRef: return Val_int(0);
}
caml_failwith_fmt("invalid value for Val_clang_ext_blocksattr_blocktype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_BlocksAttr_getType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_BlocksAttr_BlockType result = clang_ext_BlocksAttr_getType(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_blocksattr_blocktype(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AssumptionAttr_getAssumptionLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AssumptionAttr_getAssumptionLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmLabelAttr_getLabel_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_AsmLabelAttr_getLabel(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SwiftAttrAttr_getAttribute_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_SwiftAttrAttr_getAttribute(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AvailabilityAttr_getPlatform_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_AvailabilityAttr_getPlatform(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getMax_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_Attrs_getMax(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TargetAttr_getFeaturesStr_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_TargetAttr_getFeaturesStr(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CallableWhenAttr_getCallableStates_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_CallableWhenAttr_getCallableStates_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_TestTypestateAttr_ConsumedState
Clang_ext_testtypestateattr_consumedstate_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TestTypestateAttr_ConsumedState_Consumed;
case 1: return clang_ext_TestTypestateAttr_ConsumedState_Unconsumed;
}
caml_failwith_fmt("invalid value for Clang_ext_testtypestateattr_consumedstate_val: %d", Int_val(ocaml));
return clang_ext_TestTypestateAttr_ConsumedState_Consumed;
}
value
Val_clang_ext_testtypestateattr_consumedstate(enum clang_ext_TestTypestateAttr_ConsumedState v)
{
switch (v) {
case clang_ext_TestTypestateAttr_ConsumedState_Consumed: return Val_int(0);
case clang_ext_TestTypestateAttr_ConsumedState_Unconsumed: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_testtypestateattr_consumedstate: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TestTypestateAttr_getTestState_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TestTypestateAttr_ConsumedState result = clang_ext_TestTypestateAttr_getTestState(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_testtypestateattr_consumedstate(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPCaptureKindAttr_getCaptureKindVal_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPCaptureKindAttr_getCaptureKindVal(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_InitPriorityAttr_getPriority_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_InitPriorityAttr_getPriority(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getPriority_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_Attrs_getPriority(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy
Clang_ext_ompdeclaretargetdeclattr_maptypety_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy_MT_To;
case 1: return clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy_MT_Link;
}
caml_failwith_fmt("invalid value for Clang_ext_ompdeclaretargetdeclattr_maptypety_val: %d", Int_val(ocaml));
return clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy_MT_To;
}
value
Val_clang_ext_ompdeclaretargetdeclattr_maptypety(enum clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy v)
{
switch (v) {
case clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy_MT_To: return Val_int(0);
case clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy_MT_Link: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ompdeclaretargetdeclattr_maptypety: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OMPDeclareTargetDeclAttr_getMapType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OMPDeclareTargetDeclAttr_MapTypeTy result = clang_ext_OMPDeclareTargetDeclAttr_getMapType(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ompdeclaretargetdeclattr_maptypety(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getYDim_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getYDim(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CleanupAttr_getFunctionDecl_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_DeclarationName result = clang_ext_CleanupAttr_getFunctionDecl(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_declarationname(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
static value __attribute__((unused))
Val_clang_ext_versiontuple(struct clang_ext_VersionTuple v)
{
CAMLparam0();
CAMLlocal1(ocaml);
ocaml = caml_alloc_tuple(4);
{
CAMLlocal1(data);
data = Val_int(v.major);
Store_field(ocaml, 0, data);
}
{
CAMLlocal1(data);
data = Val_int(v.minor);
Store_field(ocaml, 1, data);
}
{
CAMLlocal1(data);
data = Val_int(v.subminor);
Store_field(ocaml, 2, data);
}
{
CAMLlocal1(data);
data = Val_int(v.build);
Store_field(ocaml, 3, data);
}
CAMLreturn(ocaml);
}
static struct clang_ext_VersionTuple __attribute__((unused))
Clang_ext_versiontuple_val(value ocaml)
{
CAMLparam1(ocaml);
struct clang_ext_VersionTuple v;
v.major = Int_val(Field(ocaml, 0));v.minor = Int_val(Field(ocaml, 1));v.subminor = Int_val(Field(ocaml, 2));v.build = Int_val(Field(ocaml, 3));CAMLreturnT(struct clang_ext_VersionTuple, v);
}
CAMLprim value
clang_ext_AvailabilityAttr_getObsoleted_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_VersionTuple result = clang_ext_AvailabilityAttr_getObsoleted(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_versiontuple(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_InitSegAttr_getSection_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_InitSegAttr_getSection(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_BTFDeclTagAttr_getBTFDeclTag_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_BTFDeclTagAttr_getBTFDeclTag(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExternalSourceSymbolAttr_getDefinedIn_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ExternalSourceSymbolAttr_getDefinedIn(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AllocSizeAttr_getNumElemsParam_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AllocSizeAttr_getNumElemsParam(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IFuncAttr_getResolverLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_IFuncAttr_getResolverLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmLabelAttr_getLabelLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AsmLabelAttr_getLabelLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AbiTagAttr_getTags_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AbiTagAttr_getTags_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CUDALaunchBoundsAttr_getMaxThreads_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_CUDALaunchBoundsAttr_getMaxThreads(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getBuiltinName_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getBuiltinName(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_WebAssemblyImportModuleAttr_getImportModule_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_WebAssemblyImportModuleAttr_getImportModule(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftNewTypeAttr_NewtypeKind
Clang_ext_swiftnewtypeattr_newtypekind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftNewTypeAttr_NewtypeKind_NK_Struct;
case 1: return clang_ext_SwiftNewTypeAttr_NewtypeKind_NK_Enum;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftnewtypeattr_newtypekind_val: %d", Int_val(ocaml));
return clang_ext_SwiftNewTypeAttr_NewtypeKind_NK_Struct;
}
value
Val_clang_ext_swiftnewtypeattr_newtypekind(enum clang_ext_SwiftNewTypeAttr_NewtypeKind v)
{
switch (v) {
case clang_ext_SwiftNewTypeAttr_NewtypeKind_NK_Struct: return Val_int(0);
case clang_ext_SwiftNewTypeAttr_NewtypeKind_NK_Enum: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftnewtypeattr_newtypekind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftNewTypeAttr_getNewtypeKind_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftNewTypeAttr_NewtypeKind result = clang_ext_SwiftNewTypeAttr_getNewtypeKind(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftnewtypeattr_newtypekind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_HLSLNumThreadsAttr_getZ_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_HLSLNumThreadsAttr_getZ(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NoSanitizeAttr_getSanitizers_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_NoSanitizeAttr_getSanitizers_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_CallbackAttr_getEncoding_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_CallbackAttr_getEncoding_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getXDim_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getXDim(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_UuidAttr_getGuidDecl_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_UuidAttr_getGuidDecl(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getAliasee_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getAliasee(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getHandleType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getHandleType(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_WebAssemblyImportModuleAttr_getImportModuleLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_WebAssemblyImportModuleAttr_getImportModuleLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareSimdDeclAttr_getLinears_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getLinears_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareSimdDeclAttr_getLinears(cursor, clang_ext_OMPDeclareSimdDeclAttr_getLinears_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_AvailabilityAttr_getDeprecated_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_VersionTuple result = clang_ext_AvailabilityAttr_getDeprecated(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_versiontuple(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PreferredNameAttr_getTypedefType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_PreferredNameAttr_getTypedefType(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
void
clang_ext_DiagnoseAsBuiltinAttr_getArgIndices_callback_value_callback(unsigned int arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = Val_int(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_DiagnoseAsBuiltinAttr_getArgIndices_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_DiagnoseAsBuiltinAttr_getArgIndices(cursor, clang_ext_DiagnoseAsBuiltinAttr_getArgIndices_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_TargetClonesAttr_getFeaturesStrs_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_TargetClonesAttr_getFeaturesStrs_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ErrorAttr_getUserDiagnosticLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_ErrorAttr_getUserDiagnosticLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_WebAssemblyExportNameAttr_getExportName_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_WebAssemblyExportNameAttr_getExportName(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ArgumentWithTypeTagAttr_getIsPointer_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_ArgumentWithTypeTagAttr_getIsPointer(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_UuidAttr_getGuidLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_UuidAttr_getGuidLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getAligneds_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareSimdDeclAttr_getAligneds_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getMessageLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getMessageLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_PcsAttr_PCSType
Clang_ext_pcsattr_pcstype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_PcsAttr_PCSType_AAPCS;
case 1: return clang_ext_PcsAttr_PCSType_AAPCS_VFP;
}
caml_failwith_fmt("invalid value for Clang_ext_pcsattr_pcstype_val: %d", Int_val(ocaml));
return clang_ext_PcsAttr_PCSType_AAPCS;
}
value
Val_clang_ext_pcsattr_pcstype(enum clang_ext_PcsAttr_PCSType v)
{
switch (v) {
case clang_ext_PcsAttr_PCSType_AAPCS: return Val_int(0);
case clang_ext_PcsAttr_PCSType_AAPCS_VFP: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_pcsattr_pcstype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_PcsAttr_getPCS_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_PcsAttr_PCSType result = clang_ext_PcsAttr_getPCS(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_pcsattr_pcstype(result);
CAMLreturn(data);
}
}
void
clang_ext_CallbackAttr_getEncoding_callback_value_callback(int arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = Val_int(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_CallbackAttr_getEncoding_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_CallbackAttr_getEncoding(cursor, clang_ext_CallbackAttr_getEncoding_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_Attrs_getArgumentKind_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getArgumentKind(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AvailabilityAttr_getUnavailable_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_AvailabilityAttr_getUnavailable(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
static void finalize_clang_ext_omptraitinfo(value v) {
clang_ext_OMPTraitInfo_dispose(*((struct clang_ext_OMPTraitInfo *) Data_custom_val(v)));;
}
DECLARE_OPAQUE_EX(struct clang_ext_OMPTraitInfo, clang_ext_omptraitinfo, Clang_ext_omptraitinfo_val, Val_clang_ext_omptraitinfo, finalize_clang_ext_omptraitinfo, custom_compare_default, custom_hash_default)
CAMLprim value
clang_ext_OMPDeclareVariantAttr_getTraitInfos_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_OMPTraitInfo result = clang_ext_OMPDeclareVariantAttr_getTraitInfos(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_omptraitinfo(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPAllocateDeclAttr_getAllocator_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_OMPAllocateDeclAttr_getAllocator(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_HLSLNumThreadsAttr_getY_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_HLSLNumThreadsAttr_getY(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getAnnotation_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getAnnotation(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareVariantAttr_getVariantFuncRef_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_OMPDeclareVariantAttr_getVariantFuncRef(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NoBuiltinAttr_getBuiltinNames_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_NoBuiltinAttr_getBuiltinNames_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
void
clang_ext_TargetClonesAttr_getFeaturesStrs_callback_value_callback(CXString arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_copy_string(safe_string(clang_getCString(arg0)));
clang_disposeString(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_TargetClonesAttr_getFeaturesStrs_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_TargetClonesAttr_getFeaturesStrs(cursor, clang_ext_TargetClonesAttr_getFeaturesStrs_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_Attrs_getReplacement_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getReplacement(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AMDGPUNumSGPRAttr_getNumSGPR_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AMDGPUNumSGPRAttr_getNumSGPR(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ObjCBridgeRelatedAttr_getInstanceMethod_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ObjCBridgeRelatedAttr_getInstanceMethod(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNeedDevicePtr_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNeedDevicePtr_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNeedDevicePtr(cursor, clang_ext_OMPDeclareVariantAttr_getAdjustArgsNeedDevicePtr_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getSimdlen_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_OMPDeclareSimdDeclAttr_getSimdlen(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TargetAttr_getFeaturesStrLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_TargetAttr_getFeaturesStrLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AlignedAttr_getAlignmentExpr_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_AlignedAttr_getAlignmentExpr(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind
Clang_ext_zerocallusedregsattr_zerocallusedregskind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_Skip;
case 1: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_UsedGPRArg;
case 2: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_UsedGPR;
case 3: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_UsedArg;
case 4: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_Used;
case 5: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_AllGPRArg;
case 6: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_AllGPR;
case 7: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_AllArg;
case 8: return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_All;
}
caml_failwith_fmt("invalid value for Clang_ext_zerocallusedregsattr_zerocallusedregskind_val: %d", Int_val(ocaml));
return clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_Skip;
}
value
Val_clang_ext_zerocallusedregsattr_zerocallusedregskind(enum clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind v)
{
switch (v) {
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_Skip: return Val_int(0);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_UsedGPRArg: return Val_int(1);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_UsedGPR: return Val_int(2);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_UsedArg: return Val_int(3);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_Used: return Val_int(4);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_AllGPRArg: return Val_int(5);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_AllGPR: return Val_int(6);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_AllArg: return Val_int(7);
case clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind_All: return Val_int(8);
}
caml_failwith_fmt("invalid value for Val_clang_ext_zerocallusedregsattr_zerocallusedregskind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ZeroCallUsedRegsAttr_getZeroCallUsedRegs_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ZeroCallUsedRegsAttr_ZeroCallUsedRegsKind result = clang_ext_ZeroCallUsedRegsAttr_getZeroCallUsedRegs(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_zerocallusedregsattr_zerocallusedregskind(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareSimdDeclAttr_getSteps_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getSteps_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareSimdDeclAttr_getSteps(cursor, clang_ext_OMPDeclareSimdDeclAttr_getSteps_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_TLSModelAttr_getModel_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_TLSModelAttr_getModel(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareSimdDeclAttr_getModifiers_callback_value_callback(unsigned int arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = Val_int(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getModifiers_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareSimdDeclAttr_getModifiers(cursor, clang_ext_OMPDeclareSimdDeclAttr_getModifiers_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_FormatAttr_getFirstArg_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_FormatAttr_getFirstArg(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AMDGPUNumVGPRAttr_getNumVGPR_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AMDGPUNumVGPRAttr_getNumVGPR(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_MipsInterruptAttr_InterruptType
Clang_ext_mipsinterruptattr_interrupttype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_MipsInterruptAttr_InterruptType_sw0;
case 1: return clang_ext_MipsInterruptAttr_InterruptType_sw1;
case 2: return clang_ext_MipsInterruptAttr_InterruptType_hw0;
case 3: return clang_ext_MipsInterruptAttr_InterruptType_hw1;
case 4: return clang_ext_MipsInterruptAttr_InterruptType_hw2;
case 5: return clang_ext_MipsInterruptAttr_InterruptType_hw3;
case 6: return clang_ext_MipsInterruptAttr_InterruptType_hw4;
case 7: return clang_ext_MipsInterruptAttr_InterruptType_hw5;
case 8: return clang_ext_MipsInterruptAttr_InterruptType_eic;
}
caml_failwith_fmt("invalid value for Clang_ext_mipsinterruptattr_interrupttype_val: %d", Int_val(ocaml));
return clang_ext_MipsInterruptAttr_InterruptType_sw0;
}
value
Val_clang_ext_mipsinterruptattr_interrupttype(enum clang_ext_MipsInterruptAttr_InterruptType v)
{
switch (v) {
case clang_ext_MipsInterruptAttr_InterruptType_sw0: return Val_int(0);
case clang_ext_MipsInterruptAttr_InterruptType_sw1: return Val_int(1);
case clang_ext_MipsInterruptAttr_InterruptType_hw0: return Val_int(2);
case clang_ext_MipsInterruptAttr_InterruptType_hw1: return Val_int(3);
case clang_ext_MipsInterruptAttr_InterruptType_hw2: return Val_int(4);
case clang_ext_MipsInterruptAttr_InterruptType_hw3: return Val_int(5);
case clang_ext_MipsInterruptAttr_InterruptType_hw4: return Val_int(6);
case clang_ext_MipsInterruptAttr_InterruptType_hw5: return Val_int(7);
case clang_ext_MipsInterruptAttr_InterruptType_eic: return Val_int(8);
}
caml_failwith_fmt("invalid value for Val_clang_ext_mipsinterruptattr_interrupttype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_MipsInterruptAttr_getInterrupt_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_MipsInterruptAttr_InterruptType result = clang_ext_MipsInterruptAttr_getInterrupt(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_mipsinterruptattr_interrupttype(result);
CAMLreturn(data);
}
}
enum clang_ext_ARMInterruptAttr_InterruptType
Clang_ext_arminterruptattr_interrupttype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ARMInterruptAttr_InterruptType_IRQ;
case 1: return clang_ext_ARMInterruptAttr_InterruptType_FIQ;
case 2: return clang_ext_ARMInterruptAttr_InterruptType_SWI;
case 3: return clang_ext_ARMInterruptAttr_InterruptType_ABORT;
case 4: return clang_ext_ARMInterruptAttr_InterruptType_UNDEF;
case 5: return clang_ext_ARMInterruptAttr_InterruptType_Generic;
}
caml_failwith_fmt("invalid value for Clang_ext_arminterruptattr_interrupttype_val: %d", Int_val(ocaml));
return clang_ext_ARMInterruptAttr_InterruptType_IRQ;
}
value
Val_clang_ext_arminterruptattr_interrupttype(enum clang_ext_ARMInterruptAttr_InterruptType v)
{
switch (v) {
case clang_ext_ARMInterruptAttr_InterruptType_IRQ: return Val_int(0);
case clang_ext_ARMInterruptAttr_InterruptType_FIQ: return Val_int(1);
case clang_ext_ARMInterruptAttr_InterruptType_SWI: return Val_int(2);
case clang_ext_ARMInterruptAttr_InterruptType_ABORT: return Val_int(3);
case clang_ext_ARMInterruptAttr_InterruptType_UNDEF: return Val_int(4);
case clang_ext_ARMInterruptAttr_InterruptType_Generic: return Val_int(5);
}
caml_failwith_fmt("invalid value for Val_clang_ext_arminterruptattr_interrupttype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ARMInterruptAttr_getInterrupt_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ARMInterruptAttr_InterruptType result = clang_ext_ARMInterruptAttr_getInterrupt(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_arminterruptattr_interrupttype(result);
CAMLreturn(data);
}
}
enum clang_ext_RISCVInterruptAttr_InterruptType
Clang_ext_riscvinterruptattr_interrupttype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_RISCVInterruptAttr_InterruptType_user;
case 1: return clang_ext_RISCVInterruptAttr_InterruptType_supervisor;
case 2: return clang_ext_RISCVInterruptAttr_InterruptType_machine;
}
caml_failwith_fmt("invalid value for Clang_ext_riscvinterruptattr_interrupttype_val: %d", Int_val(ocaml));
return clang_ext_RISCVInterruptAttr_InterruptType_user;
}
value
Val_clang_ext_riscvinterruptattr_interrupttype(enum clang_ext_RISCVInterruptAttr_InterruptType v)
{
switch (v) {
case clang_ext_RISCVInterruptAttr_InterruptType_user: return Val_int(0);
case clang_ext_RISCVInterruptAttr_InterruptType_supervisor: return Val_int(1);
case clang_ext_RISCVInterruptAttr_InterruptType_machine: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_riscvinterruptattr_interrupttype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_RISCVInterruptAttr_getInterrupt_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_RISCVInterruptAttr_InterruptType result = clang_ext_RISCVInterruptAttr_getInterrupt(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_riscvinterruptattr_interrupttype(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getMin_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_Attrs_getMin(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_EnumExtensibilityAttr_Kind
Clang_ext_enumextensibilityattr_kind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_EnumExtensibilityAttr_Kind_Closed;
case 1: return clang_ext_EnumExtensibilityAttr_Kind_Open;
}
caml_failwith_fmt("invalid value for Clang_ext_enumextensibilityattr_kind_val: %d", Int_val(ocaml));
return clang_ext_EnumExtensibilityAttr_Kind_Closed;
}
value
Val_clang_ext_enumextensibilityattr_kind(enum clang_ext_EnumExtensibilityAttr_Kind v)
{
switch (v) {
case clang_ext_EnumExtensibilityAttr_Kind_Closed: return Val_int(0);
case clang_ext_EnumExtensibilityAttr_Kind_Open: return Val_int(1);
}
caml_failwith_fmt("invalid value for Val_clang_ext_enumextensibilityattr_kind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_EnumExtensibilityAttr_getExtensibility_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_EnumExtensibilityAttr_Kind result = clang_ext_EnumExtensibilityAttr_getExtensibility(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_enumextensibilityattr_kind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AllocAlignAttr_getParamIndex_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AllocAlignAttr_getParamIndex(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DiagnoseAsBuiltinAttr_getArgIndices_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_DiagnoseAsBuiltinAttr_getArgIndices_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AvailabilityAttr_getIntroduced_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_VersionTuple result = clang_ext_AvailabilityAttr_getIntroduced(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_versiontuple(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_MaxFieldAlignmentAttr_getAlignment_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_MaxFieldAlignmentAttr_getAlignment(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getAlignment_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_Attrs_getAlignment(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AddressSpaceAttr_getAddressSpace_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_AddressSpaceAttr_getAddressSpace(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ModeAttr_getMode_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ModeAttr_getMode(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getArg_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_Attrs_getArg(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
void
clang_ext_Attrs_getCpus_callback_value_callback(CXString arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_copy_string(safe_string(clang_getCString(arg0)));
clang_disposeString(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_Attrs_getCpus_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_Attrs_getCpus(cursor, clang_ext_Attrs_getCpus_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_BTFTypeTagAttr_getBTFTypeTag_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_BTFTypeTagAttr_getBTFTypeTag(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OpenCLIntelReqdSubGroupSizeAttr_getSubGroupSize_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OpenCLIntelReqdSubGroupSizeAttr_getSubGroupSize(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ArgumentWithTypeTagAttr_getArgumentIdx_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_ArgumentWithTypeTagAttr_getArgumentIdx(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AvailabilityAttr_getStrict_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_AvailabilityAttr_getStrict(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum clang_ext_CFGuardAttr_GuardArg
Clang_ext_cfguardattr_guardarg_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CFGuardAttr_GuardArg_nocf;
}
caml_failwith_fmt("invalid value for Clang_ext_cfguardattr_guardarg_val: %d", Int_val(ocaml));
return clang_ext_CFGuardAttr_GuardArg_nocf;
}
value
Val_clang_ext_cfguardattr_guardarg(enum clang_ext_CFGuardAttr_GuardArg v)
{
switch (v) {
case clang_ext_CFGuardAttr_GuardArg_nocf: return Val_int(0);
}
caml_failwith_fmt("invalid value for Val_clang_ext_cfguardattr_guardarg: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_CFGuardAttr_getGuard_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_CFGuardAttr_GuardArg result = clang_ext_CFGuardAttr_getGuard(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_cfguardattr_guardarg(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OwnershipAttr_getModule_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_OwnershipAttr_getModule(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_MinVectorWidthAttr_getVectorWidth_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_MinVectorWidthAttr_getVectorWidth(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeTagForDatatypeAttr_getLayoutCompatible_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_TypeTagForDatatypeAttr_getLayoutCompatible(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNothing_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNothing_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNothing(cursor, clang_ext_OMPDeclareVariantAttr_getAdjustArgsNothing_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_InitSegAttr_getSectionLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_InitSegAttr_getSectionLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_VecTypeHintAttr_getTypeHint_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_VecTypeHintAttr_getTypeHint(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getTCBNameLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getTCBNameLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareVariantAttr_getAdjustArgsNothing_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareVariantAttr_getAdjustArgsNothing_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExternalSourceSymbolAttr_getLanguageLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_ExternalSourceSymbolAttr_getLanguageLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ObjCRuntimeNameAttr_getMetadataNameLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_ObjCRuntimeNameAttr_getMetadataNameLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_ConsumableAttr_ConsumedState
Clang_ext_consumableattr_consumedstate_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ConsumableAttr_ConsumedState_Unknown;
case 1: return clang_ext_ConsumableAttr_ConsumedState_Consumed;
case 2: return clang_ext_ConsumableAttr_ConsumedState_Unconsumed;
}
caml_failwith_fmt("invalid value for Clang_ext_consumableattr_consumedstate_val: %d", Int_val(ocaml));
return clang_ext_ConsumableAttr_ConsumedState_Unknown;
}
value
Val_clang_ext_consumableattr_consumedstate(enum clang_ext_ConsumableAttr_ConsumedState v)
{
switch (v) {
case clang_ext_ConsumableAttr_ConsumedState_Unknown: return Val_int(0);
case clang_ext_ConsumableAttr_ConsumedState_Consumed: return Val_int(1);
case clang_ext_ConsumableAttr_ConsumedState_Unconsumed: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_consumableattr_consumedstate: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ConsumableAttr_getDefaultState_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ConsumableAttr_ConsumedState result = clang_ext_ConsumableAttr_getDefaultState(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_consumableattr_consumedstate(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_BuiltinAttr_getID_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_BuiltinAttr_getID(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AssumptionAttr_getAssumption_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_AssumptionAttr_getAssumption(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getBridgedType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getBridgedType(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getModifiers_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareSimdDeclAttr_getModifiers_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SwiftAttrAttr_getAttributeLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_SwiftAttrAttr_getAttributeLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_SetTypestateAttr_ConsumedState
Clang_ext_settypestateattr_consumedstate_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SetTypestateAttr_ConsumedState_Unknown;
case 1: return clang_ext_SetTypestateAttr_ConsumedState_Consumed;
case 2: return clang_ext_SetTypestateAttr_ConsumedState_Unconsumed;
}
caml_failwith_fmt("invalid value for Clang_ext_settypestateattr_consumedstate_val: %d", Int_val(ocaml));
return clang_ext_SetTypestateAttr_ConsumedState_Unknown;
}
value
Val_clang_ext_settypestateattr_consumedstate(enum clang_ext_SetTypestateAttr_ConsumedState v)
{
switch (v) {
case clang_ext_SetTypestateAttr_ConsumedState_Unknown: return Val_int(0);
case clang_ext_SetTypestateAttr_ConsumedState_Consumed: return Val_int(1);
case clang_ext_SetTypestateAttr_ConsumedState_Unconsumed: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_settypestateattr_consumedstate: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SetTypestateAttr_getNewState_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SetTypestateAttr_ConsumedState result = clang_ext_SetTypestateAttr_getNewState(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_settypestateattr_consumedstate(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ObjCBridgeRelatedAttr_getClassMethod_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ObjCBridgeRelatedAttr_getClassMethod(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPReferencedVarAttr_getRef_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_OMPReferencedVarAttr_getRef(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AllocSizeAttr_getElemSizeParam_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_AllocSizeAttr_getElemSizeParam(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_VisibilityAttr_VisibilityType
Clang_ext_visibilityattr_visibilitytype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_VisibilityAttr_VisibilityType_Default;
case 1: return clang_ext_VisibilityAttr_VisibilityType_Hidden;
case 2: return clang_ext_VisibilityAttr_VisibilityType_Protected;
}
caml_failwith_fmt("invalid value for Clang_ext_visibilityattr_visibilitytype_val: %d", Int_val(ocaml));
return clang_ext_VisibilityAttr_VisibilityType_Default;
}
value
Val_clang_ext_visibilityattr_visibilitytype(enum clang_ext_VisibilityAttr_VisibilityType v)
{
switch (v) {
case clang_ext_VisibilityAttr_VisibilityType_Default: return Val_int(0);
case clang_ext_VisibilityAttr_VisibilityType_Hidden: return Val_int(1);
case clang_ext_VisibilityAttr_VisibilityType_Protected: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_visibilityattr_visibilitytype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_VisibilityAttr_getVisibility_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_VisibilityAttr_VisibilityType result = clang_ext_VisibilityAttr_getVisibility(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_visibilityattr_visibilitytype(result);
CAMLreturn(data);
}
}
enum clang_ext_TypeVisibilityAttr_VisibilityType
Clang_ext_typevisibilityattr_visibilitytype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_TypeVisibilityAttr_VisibilityType_Default;
case 1: return clang_ext_TypeVisibilityAttr_VisibilityType_Hidden;
case 2: return clang_ext_TypeVisibilityAttr_VisibilityType_Protected;
}
caml_failwith_fmt("invalid value for Clang_ext_typevisibilityattr_visibilitytype_val: %d", Int_val(ocaml));
return clang_ext_TypeVisibilityAttr_VisibilityType_Default;
}
value
Val_clang_ext_typevisibilityattr_visibilitytype(enum clang_ext_TypeVisibilityAttr_VisibilityType v)
{
switch (v) {
case clang_ext_TypeVisibilityAttr_VisibilityType_Default: return Val_int(0);
case clang_ext_TypeVisibilityAttr_VisibilityType_Hidden: return Val_int(1);
case clang_ext_TypeVisibilityAttr_VisibilityType_Protected: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_typevisibilityattr_visibilitytype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_TypeVisibilityAttr_getVisibility_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_TypeVisibilityAttr_VisibilityType result = clang_ext_TypeVisibilityAttr_getVisibility(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_typevisibilityattr_visibilitytype(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ExternalSourceSymbolAttr_getLanguage_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ExternalSourceSymbolAttr_getLanguage(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getReplacementLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getReplacementLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getAlignments_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareSimdDeclAttr_getAlignments_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getLinears_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareSimdDeclAttr_getLinears_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_NSErrorDomainAttr_getErrorDomain_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_NSErrorDomainAttr_getErrorDomain(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ErrorAttr_getUserDiagnostic_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ErrorAttr_getUserDiagnostic(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_XRayLogArgsAttr_getArgumentCount_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_XRayLogArgsAttr_getArgumentCount(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getMessage_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getMessage(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ArgumentWithTypeTagAttr_getTypeTagIdx_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_ArgumentWithTypeTagAttr_getTypeTagIdx(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_UuidAttr_getGuid_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_UuidAttr_getGuid(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getZDim_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getZDim(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getHandleTypeLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getHandleTypeLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareSimdDeclAttr_getUniforms_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getUniforms_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareSimdDeclAttr_getUniforms(cursor, clang_ext_OMPDeclareSimdDeclAttr_getUniforms_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
enum clang_ext_LoopHintAttr_OptionType
Clang_ext_loophintattr_optiontype_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_LoopHintAttr_OptionType_Vectorize;
case 1: return clang_ext_LoopHintAttr_OptionType_VectorizeWidth;
case 2: return clang_ext_LoopHintAttr_OptionType_Interleave;
case 3: return clang_ext_LoopHintAttr_OptionType_InterleaveCount;
case 4: return clang_ext_LoopHintAttr_OptionType_Unroll;
case 5: return clang_ext_LoopHintAttr_OptionType_UnrollCount;
case 6: return clang_ext_LoopHintAttr_OptionType_UnrollAndJam;
case 7: return clang_ext_LoopHintAttr_OptionType_UnrollAndJamCount;
case 8: return clang_ext_LoopHintAttr_OptionType_PipelineDisabled;
case 9: return clang_ext_LoopHintAttr_OptionType_PipelineInitiationInterval;
case 10: return clang_ext_LoopHintAttr_OptionType_Distribute;
case 11: return clang_ext_LoopHintAttr_OptionType_VectorizePredicate;
}
caml_failwith_fmt("invalid value for Clang_ext_loophintattr_optiontype_val: %d", Int_val(ocaml));
return clang_ext_LoopHintAttr_OptionType_Vectorize;
}
value
Val_clang_ext_loophintattr_optiontype(enum clang_ext_LoopHintAttr_OptionType v)
{
switch (v) {
case clang_ext_LoopHintAttr_OptionType_Vectorize: return Val_int(0);
case clang_ext_LoopHintAttr_OptionType_VectorizeWidth: return Val_int(1);
case clang_ext_LoopHintAttr_OptionType_Interleave: return Val_int(2);
case clang_ext_LoopHintAttr_OptionType_InterleaveCount: return Val_int(3);
case clang_ext_LoopHintAttr_OptionType_Unroll: return Val_int(4);
case clang_ext_LoopHintAttr_OptionType_UnrollCount: return Val_int(5);
case clang_ext_LoopHintAttr_OptionType_UnrollAndJam: return Val_int(6);
case clang_ext_LoopHintAttr_OptionType_UnrollAndJamCount: return Val_int(7);
case clang_ext_LoopHintAttr_OptionType_PipelineDisabled: return Val_int(8);
case clang_ext_LoopHintAttr_OptionType_PipelineInitiationInterval: return Val_int(9);
case clang_ext_LoopHintAttr_OptionType_Distribute: return Val_int(10);
case clang_ext_LoopHintAttr_OptionType_VectorizePredicate: return Val_int(11);
}
caml_failwith_fmt("invalid value for Val_clang_ext_loophintattr_optiontype: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_LoopHintAttr_getOption_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_LoopHintAttr_OptionType result = clang_ext_LoopHintAttr_getOption(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_loophintattr_optiontype(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_ObjCBridgeRelatedAttr_getRelatedClass_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_ObjCBridgeRelatedAttr_getRelatedClass(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_WebAssemblyImportNameAttr_getImportName_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_WebAssemblyImportNameAttr_getImportName(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
void
clang_ext_NoSanitizeAttr_getSanitizers_callback_value_callback(CXString arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_copy_string(safe_string(clang_getCString(arg0)));
clang_disposeString(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_NoSanitizeAttr_getSanitizers_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_NoSanitizeAttr_getSanitizers(cursor, clang_ext_NoSanitizeAttr_getSanitizers_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
enum clang_ext_CallableWhenAttr_ConsumedState
Clang_ext_callablewhenattr_consumedstate_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_CallableWhenAttr_ConsumedState_Unknown;
case 1: return clang_ext_CallableWhenAttr_ConsumedState_Consumed;
case 2: return clang_ext_CallableWhenAttr_ConsumedState_Unconsumed;
}
caml_failwith_fmt("invalid value for Clang_ext_callablewhenattr_consumedstate_val: %d", Int_val(ocaml));
return clang_ext_CallableWhenAttr_ConsumedState_Unknown;
}
value
Val_clang_ext_callablewhenattr_consumedstate(enum clang_ext_CallableWhenAttr_ConsumedState v)
{
switch (v) {
case clang_ext_CallableWhenAttr_ConsumedState_Unknown: return Val_int(0);
case clang_ext_CallableWhenAttr_ConsumedState_Consumed: return Val_int(1);
case clang_ext_CallableWhenAttr_ConsumedState_Unconsumed: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_callablewhenattr_consumedstate: %d", v);
return Val_int(0);
}
void
clang_ext_CallableWhenAttr_getCallableStates_callback_value_callback(enum clang_ext_CallableWhenAttr_ConsumedState arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = Val_clang_ext_callablewhenattr_consumedstate(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_CallableWhenAttr_getCallableStates_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_CallableWhenAttr_getCallableStates(cursor, clang_ext_CallableWhenAttr_getCallableStates_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
enum clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy
Clang_ext_ompdeclaresimddeclattr_branchstatety_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy_BS_Undefined;
case 1: return clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy_BS_Inbranch;
case 2: return clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy_BS_Notinbranch;
}
caml_failwith_fmt("invalid value for Clang_ext_ompdeclaresimddeclattr_branchstatety_val: %d", Int_val(ocaml));
return clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy_BS_Undefined;
}
value
Val_clang_ext_ompdeclaresimddeclattr_branchstatety(enum clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy v)
{
switch (v) {
case clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy_BS_Undefined: return Val_int(0);
case clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy_BS_Inbranch: return Val_int(1);
case clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy_BS_Notinbranch: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ompdeclaresimddeclattr_branchstatety: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getBranchState_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OMPDeclareSimdDeclAttr_BranchStateTy result = clang_ext_OMPDeclareSimdDeclAttr_getBranchState(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ompdeclaresimddeclattr_branchstatety(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_AsmLabelAttr_getIsLiteralLabel_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_AsmLabelAttr_getIsLiteralLabel(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SwiftBridgeAttr_getSwiftType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_SwiftBridgeAttr_getSwiftType(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FormatArgAttr_getFormatIdx_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_FormatArgAttr_getFormatIdx(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_FormatAttr_getFormatIdx_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_FormatAttr_getFormatIdx(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_TypeTagForDatatypeAttr_getMustBeNull_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_TypeTagForDatatypeAttr_getMustBeNull(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
enum clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy
Clang_ext_ompallocatedeclattr_allocatortypety_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPNullMemAlloc;
case 1: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPDefaultMemAlloc;
case 2: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPLargeCapMemAlloc;
case 3: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPConstMemAlloc;
case 4: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPHighBWMemAlloc;
case 5: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPLowLatMemAlloc;
case 6: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPCGroupMemAlloc;
case 7: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPPTeamMemAlloc;
case 8: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPThreadMemAlloc;
case 9: return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPUserDefinedMemAlloc;
}
caml_failwith_fmt("invalid value for Clang_ext_ompallocatedeclattr_allocatortypety_val: %d", Int_val(ocaml));
return clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPNullMemAlloc;
}
value
Val_clang_ext_ompallocatedeclattr_allocatortypety(enum clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy v)
{
switch (v) {
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPNullMemAlloc: return Val_int(0);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPDefaultMemAlloc: return Val_int(1);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPLargeCapMemAlloc: return Val_int(2);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPConstMemAlloc: return Val_int(3);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPHighBWMemAlloc: return Val_int(4);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPLowLatMemAlloc: return Val_int(5);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPCGroupMemAlloc: return Val_int(6);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPPTeamMemAlloc: return Val_int(7);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPThreadMemAlloc: return Val_int(8);
case clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy_OMPUserDefinedMemAlloc: return Val_int(9);
}
caml_failwith_fmt("invalid value for Val_clang_ext_ompallocatedeclattr_allocatortypety: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_OMPAllocateDeclAttr_getAllocatorType_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_OMPAllocateDeclAttr_AllocatorTypeTy result = clang_ext_OMPAllocateDeclAttr_getAllocatorType(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_ompallocatedeclattr_allocatortypety(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getNameLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getNameLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getName_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getName(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SuppressAttr_getDiagnosticIdentifiers_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_SuppressAttr_getDiagnosticIdentifiers_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getSteps_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OMPDeclareSimdDeclAttr_getSteps_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_WebAssemblyExportNameAttr_getExportNameLength_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_WebAssemblyExportNameAttr_getExportNameLength(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
void
clang_ext_OMPDeclareSimdDeclAttr_getAlignments_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_OMPDeclareSimdDeclAttr_getAlignments_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_OMPDeclareSimdDeclAttr_getAlignments(cursor, clang_ext_OMPDeclareSimdDeclAttr_getAlignments_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_MSVtorDispAttr_getVdm_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_MSVtorDispAttr_getVdm(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getCond_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXCursor result = clang_ext_Attrs_getCond(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_cxcursor(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_IBOutletCollectionAttr_getInterface_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_TypeLoc result = clang_ext_IBOutletCollectionAttr_getInterface(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_typeloc(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
enum clang_ext_ObjCMethodFamilyAttr_FamilyKind
Clang_ext_objcmethodfamilyattr_familykind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_None;
case 1: return clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_alloc;
case 2: return clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_copy;
case 3: return clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_init;
case 4: return clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_mutableCopy;
case 5: return clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_new;
}
caml_failwith_fmt("invalid value for Clang_ext_objcmethodfamilyattr_familykind_val: %d", Int_val(ocaml));
return clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_None;
}
value
Val_clang_ext_objcmethodfamilyattr_familykind(enum clang_ext_ObjCMethodFamilyAttr_FamilyKind v)
{
switch (v) {
case clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_None: return Val_int(0);
case clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_alloc: return Val_int(1);
case clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_copy: return Val_int(2);
case clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_init: return Val_int(3);
case clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_mutableCopy: return Val_int(4);
case clang_ext_ObjCMethodFamilyAttr_FamilyKind_OMF_new: return Val_int(5);
}
caml_failwith_fmt("invalid value for Val_clang_ext_objcmethodfamilyattr_familykind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_ObjCMethodFamilyAttr_getFamily_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_ObjCMethodFamilyAttr_FamilyKind result = clang_ext_ObjCMethodFamilyAttr_getFamily(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_objcmethodfamilyattr_familykind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_SwiftAsyncErrorAttr_getHandlerParamIdx_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_SwiftAsyncErrorAttr_getHandlerParamIdx(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
enum clang_ext_SwiftAsyncAttr_Kind
Clang_ext_swiftasyncattr_kind_val(value ocaml)
{
switch (Int_val(ocaml)) {
case 0: return clang_ext_SwiftAsyncAttr_Kind_None;
case 1: return clang_ext_SwiftAsyncAttr_Kind_SwiftPrivate;
case 2: return clang_ext_SwiftAsyncAttr_Kind_NotSwiftPrivate;
}
caml_failwith_fmt("invalid value for Clang_ext_swiftasyncattr_kind_val: %d", Int_val(ocaml));
return clang_ext_SwiftAsyncAttr_Kind_None;
}
value
Val_clang_ext_swiftasyncattr_kind(enum clang_ext_SwiftAsyncAttr_Kind v)
{
switch (v) {
case clang_ext_SwiftAsyncAttr_Kind_None: return Val_int(0);
case clang_ext_SwiftAsyncAttr_Kind_SwiftPrivate: return Val_int(1);
case clang_ext_SwiftAsyncAttr_Kind_NotSwiftPrivate: return Val_int(2);
}
caml_failwith_fmt("invalid value for Val_clang_ext_swiftasyncattr_kind: %d", v);
return Val_int(0);
}
CAMLprim value
clang_ext_SwiftAsyncAttr_getKind_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
enum clang_ext_SwiftAsyncAttr_Kind result = clang_ext_SwiftAsyncAttr_getKind(cursor);
{
CAMLlocal1(data);
data = Val_clang_ext_swiftasyncattr_kind(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getKind_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getKind(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_HLSLNumThreadsAttr_getX_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
int result = clang_ext_HLSLNumThreadsAttr_getX(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_PatchableFunctionEntryAttr_getCount_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_PatchableFunctionEntryAttr_getCount(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_DiagnoseAsBuiltinAttr_getFunction_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
struct clang_ext_DeclarationName result = clang_ext_DiagnoseAsBuiltinAttr_getFunction(cursor);
{
CAMLlocal1(data);
data = caml_alloc_tuple(2);
Store_field(data, 0, Val_clang_ext_declarationname(result));
Store_field(data, 1, safe_field(cursor_ocaml, 1));
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getDelayedArgs_Size_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getDelayedArgs_Size(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
void
clang_ext_AbiTagAttr_getTags_callback_value_callback(CXString arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_copy_string(safe_string(clang_getCString(arg0)));
clang_disposeString(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_AbiTagAttr_getTags_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_AbiTagAttr_getTags(cursor, clang_ext_AbiTagAttr_getTags_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_Attrs_getNumber_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_Attrs_getNumber(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_Attrs_getTCBName_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
CXString result = clang_ext_Attrs_getTCBName(cursor);
{
CAMLlocal1(data);
data = caml_copy_string(safe_string(clang_getCString(result)));
clang_disposeString(result);
CAMLreturn(data);
}
}
CAMLprim value
clang_ext_OpenCLUnrollHintAttr_getUnrollHint_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
unsigned int result = clang_ext_OpenCLUnrollHintAttr_getUnrollHint(cursor);
{
CAMLlocal1(data);
data = Val_int(result);
CAMLreturn(data);
}
}
void
clang_ext_NoBuiltinAttr_getBuiltinNames_callback_value_callback(CXString arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_copy_string(safe_string(clang_getCString(arg0)));
clang_disposeString(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_NoBuiltinAttr_getBuiltinNames_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_NoBuiltinAttr_getBuiltinNames(cursor, clang_ext_NoBuiltinAttr_getBuiltinNames_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
CAMLprim value
clang_ext_MSInheritanceAttr_getBestCase_wrapper(value cursor_ocaml)
{
CAMLparam1(cursor_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
_Bool result = clang_ext_MSInheritanceAttr_getBestCase(cursor);
{
CAMLlocal1(data);
data = Val_bool(result);
CAMLreturn(data);
}
}
void
clang_ext_NonNullAttr_getArgs_callback_value_callback(unsigned int arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = Val_int(arg0); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_NonNullAttr_getArgs_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_NonNullAttr_getArgs(cursor, clang_ext_NonNullAttr_getArgs_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
void
clang_ext_AcquireCapabilityAttr_getArgs_callback_value_callback(CXCursor arg0, void * arg1)
{
CAMLparam0();
CAMLlocal3(result, f, arg0_ocaml);
f = *((value *) ((value **)arg1)[0]);
arg0_ocaml = caml_alloc_tuple(2);
Store_field(arg0_ocaml, 0, Val_cxcursor(arg0));
Store_field(arg0_ocaml, 1, safe_field(*((value **)arg1)[1], 1)); caml_callback(f, arg0_ocaml);
}
CAMLprim value
clang_ext_AcquireCapabilityAttr_getArgs_wrapper(value cursor_ocaml, value callback_value_ocaml)
{
CAMLparam2(cursor_ocaml, callback_value_ocaml);
CXCursor cursor;
cursor = Cxcursor_val(Field(cursor_ocaml, 0));
clang_ext_AcquireCapabilityAttr_getArgs(cursor, clang_ext_AcquireCapabilityAttr_getArgs_callback_value_callback, (value *[]){&callback_value_ocaml,&cursor_ocaml});
CAMLreturn(Val_unit);
}
| /* This file is auto-generated by stubgen tool.
* It should not be modified by hand and it should not be versioned
* (except by continuous integration on the dedicated bootstrap branch). */ |
iconview.ml | (**************************************************************************)
(* Lablgtk - Examples *)
(* *)
(* This code is in the public domain. *)
(* You may freely copy parts of it in your application. *)
(* *)
(**************************************************************************)
let files = [
"gnome-fs-regular.png" ;
"gnome-fs-directory.png" ]
let error ?parent message =
let w =
GWindow.message_dialog ~message
~message_type:`ERROR
~buttons:GWindow.Buttons.close
?parent ~destroy_with_parent:true ~show:true () in
w#connect#response (fun _ -> w#destroy ()) ;
()
let sort_func dir_c name_c (m : #GTree.model) i1 i2 =
let is_dir_1 = m#get ~column:dir_c ~row:i1 in
let is_dir_2 = m#get ~column:dir_c ~row:i2 in
if not is_dir_1 && is_dir_2
then 1
else if is_dir_1 && not is_dir_2
then -1
else
let name_1 = m#get ~column:name_c ~row:i1 in
let name_2 = m#get ~column:name_c ~row:i2 in
compare name_1 name_2
type data =
{ store : GTree.list_store ;
path_c : string GTree.column ;
name_c : string GTree.column ;
icon_c : GdkPixbuf.pixbuf GTree.column ;
dir_c : bool GTree.column ;
mutable parent : string ;
file_pb : GdkPixbuf.pixbuf ;
folder_pb : GdkPixbuf.pixbuf ;
}
let create_store file_pb folder_pb parent =
let columns = new GTree.column_list in
let path_c = columns#add Gobject.Data.string in
let name_c = columns#add Gobject.Data.string in
let icon_c = columns#add (Gobject.Data.gobject_by_name "GdkPixbuf") in
let dir_c = columns#add Gobject.Data.boolean in
let store = GTree.list_store columns in
store#set_sort_func 0 (sort_func dir_c name_c) ;
store#set_sort_column_id 0 `ASCENDING ;
{ store = store ; path_c = path_c ;
name_c = name_c ; icon_c = icon_c ;
dir_c = dir_c ; parent = parent ;
file_pb = file_pb ; folder_pb = folder_pb }
let fill_store d =
d.store#clear () ;
Array.iter
(fun name ->
if name.[0] <> '.' then begin
let path = Filename.concat d.parent name in
let is_dir = (Unix.stat path).Unix.st_kind = Unix.S_DIR in
let display_name = Glib.Convert.filename_to_utf8 name in
let row = d.store#append () in
d.store#set ~row ~column:d.path_c path ;
d.store#set ~row ~column:d.name_c display_name ;
d.store#set ~row ~column:d.dir_c is_dir ;
d.store#set ~row ~column:d.icon_c (if is_dir then d.folder_pb else d.file_pb)
end)
(Sys.readdir d.parent)
let refill_store view d =
view#set_model None ;
fill_store d ;
view#set_model (Some (d.store :> GTree.model))
let up_clicked button view d () =
d.parent <- Filename.dirname d.parent ;
refill_store view d ;
button#misc#set_sensitive (d.parent <> "/")
let home_dir =
match Glib.get_home_dir () with
| None -> exit 2
| Some s -> s
let home_clicked button view d () =
d.parent <- home_dir ;
refill_store view d ;
button#misc#set_sensitive true
let item_activated button view d path =
let row = d.store#get_iter path in
let name = d.store#get ~row ~column:d.path_c in
Printf.eprintf "tree_path = %s path = %s\n%!" (GTree.Path.to_string path) name ;
let is_dir = d.store#get ~row ~column:d.dir_c in
if is_dir then begin
let path = d.store#get ~row ~column:d.path_c in
d.parent <- path ;
refill_store view d ;
button#misc#set_sensitive true
end
let do_iconview window =
match
try List.map GdkPixbuf.from_file files
with exn -> error ~parent:window (Printexc.to_string exn) ; []
with
| [ file_pb ; folder_pb ] ->
let vbox = GPack.vbox ~packing:window#add () in
let toolbar = GButton.toolbar ~packing:vbox#pack () in
let up_button =
GButton.tool_button ~stock:`GO_UP ~packing:toolbar#insert () in
up_button#set_is_important true ;
up_button#misc#set_sensitive false ;
let home_button =
GButton.tool_button ~stock:`HOME ~packing:toolbar#insert () in
home_button#set_is_important true ;
let sw = GBin.scrolled_window
~hpolicy:`AUTOMATIC ~vpolicy:`AUTOMATIC
~shadow_type:`ETCHED_IN
~packing:(vbox#pack ~expand:true) () in
let data = create_store file_pb folder_pb "/" in
fill_store data ;
let iv = GTree.icon_view
~model:data.store
~selection_mode:`MULTIPLE ~packing:sw#add () in
iv#set_text_column data.name_c ;
iv#set_pixbuf_column data.icon_c ;
up_button#connect#clicked (up_clicked up_button iv data) ;
home_button#connect#clicked (home_clicked up_button iv data) ;
iv#connect#item_activated (item_activated up_button iv data) ;
iv#misc#grab_focus ()
| _ -> ()
let main =
GMain.init ();
let w = GWindow.window ~title:"GtkIconView demo" ~width:650 ~height:400 () in
w#connect#destroy GMain.quit ;
do_iconview w ;
w#show () ;
GMain.main ()
| (**************************************************************************)
(* Lablgtk - Examples *)
(* *)
(* This code is in the public domain. *)
(* You may freely copy parts of it in your application. *)
(* *)
(**************************************************************************)
|
dune |
(library
(name lwt_log_js)
(public_name js_of_ocaml-lwt.logger)
(synopsis "Lwt logger for js_of_ocaml.")
(optional)
(libraries js_of_ocaml lwt lwt_log.core)
(preprocess
(pps js_of_ocaml-ppx)))
| |
state.ml | (* Defines all high-level datatypes for the TLS library. It is opaque to clients
of this library, and only used from within the library. *)
open Core
open Mirage_crypto
type hmac_key = Cstruct.t
(* initialisation vector style, depending on TLS version *)
type iv_mode =
| Iv of Cstruct.t (* traditional CBC (reusing last cipherblock) *)
| Random_iv (* TLS 1.1 and higher explicit IV (we use random) *)
type 'k cbc_cipher = (module Cipher_block.S.CBC with type key = 'k)
type 'k cbc_state = {
cipher : 'k cbc_cipher ;
cipher_secret : 'k ;
iv_mode : iv_mode ;
hmac : Hash.hash ;
hmac_secret : hmac_key
}
type nonce = Cstruct.t
type 'k aead_cipher = (module AEAD with type key = 'k)
type 'k aead_state = {
cipher : 'k aead_cipher ;
cipher_secret : 'k ;
nonce : nonce ;
explicit_nonce : bool ; (* RFC 7905: no explicit nonce, instead TLS 1.3 construction is adapted *)
}
(* state of a symmetric cipher *)
type cipher_st =
| CBC : 'k cbc_state -> cipher_st
| AEAD : 'k aead_state -> cipher_st
(* context of a TLS connection (both in and out has each one of these) *)
type crypto_context = {
sequence : int64 ; (* sequence number *)
cipher_st : cipher_st ; (* cipher state *)
}
(* the raw handshake log we need to carry around *)
type hs_log = Cstruct.t list
type dh_secret = [
| `Finite_field of Mirage_crypto_pk.Dh.secret
| `P256 of Mirage_crypto_ec.P256.Dh.secret
| `P384 of Mirage_crypto_ec.P384.Dh.secret
| `P521 of Mirage_crypto_ec.P521.Dh.secret
| `X25519 of Mirage_crypto_ec.X25519.secret
]
(* a collection of client and server verify bytes for renegotiation *)
type reneg_params = Cstruct.t * Cstruct.t
type common_session_data = {
server_random : Cstruct.t ; (* 32 bytes random from the server hello *)
client_random : Cstruct.t ; (* 32 bytes random from the client hello *)
peer_certificate_chain : X509.Certificate.t list ;
peer_certificate : X509.Certificate.t option ;
trust_anchor : X509.Certificate.t option ;
received_certificates : X509.Certificate.t list ;
own_certificate : X509.Certificate.t list ;
own_private_key : X509.Private_key.t option ;
own_name : [`host] Domain_name.t option ;
client_auth : bool ;
master_secret : master_secret ;
alpn_protocol : string option ; (* selected alpn protocol after handshake *)
}
type session_data = {
common_session_data : common_session_data ;
client_version : tls_any_version ; (* version in client hello (needed in RSA client key exchange) *)
ciphersuite : Ciphersuite.ciphersuite ;
group : group option ;
renegotiation : reneg_params ; (* renegotiation data *)
session_id : Cstruct.t ;
extended_ms : bool ;
}
(* state machine of the server *)
type server_handshake_state =
| AwaitClientHello (* initial state *)
| AwaitClientHelloRenegotiate
| AwaitClientCertificate_RSA of session_data * hs_log
| AwaitClientCertificate_DHE of session_data * dh_secret * hs_log
| AwaitClientKeyExchange_RSA of session_data * hs_log (* server hello done is sent, and RSA key exchange used, waiting for a client key exchange message *)
| AwaitClientKeyExchange_DHE of session_data * dh_secret * hs_log (* server hello done is sent, and DHE_RSA key exchange used, waiting for client key exchange *)
| AwaitClientCertificateVerify of session_data * crypto_context * crypto_context * hs_log
| AwaitClientChangeCipherSpec of session_data * crypto_context * crypto_context * hs_log (* client key exchange received, next should be change cipher spec *)
| AwaitClientChangeCipherSpecResume of session_data * crypto_context * Cstruct.t * hs_log (* resumption: next should be change cipher spec *)
| AwaitClientFinished of session_data * hs_log (* change cipher spec received, next should be the finished including a hmac over all handshake packets *)
| AwaitClientFinishedResume of session_data * Cstruct.t * hs_log (* change cipher spec received, next should be the finished including a hmac over all handshake packets *)
| Established (* handshake successfully completed *)
(* state machine of the client *)
type client_handshake_state =
| ClientInitial (* initial state *)
| AwaitServerHello of client_hello * (group * dh_secret) list * hs_log (* client hello is sent, handshake_params are half-filled *)
| AwaitServerHelloRenegotiate of session_data * client_hello * hs_log (* client hello is sent, handshake_params are half-filled *)
| AwaitCertificate_RSA of session_data * hs_log (* certificate expected with RSA key exchange *)
| AwaitCertificate_DHE of session_data * hs_log (* certificate expected with DHE key exchange *)
| AwaitServerKeyExchange_DHE of session_data * hs_log (* server key exchange expected with DHE *)
| AwaitCertificateRequestOrServerHelloDone of session_data * Cstruct.t * Cstruct.t * hs_log (* server hello done expected, client key exchange and premastersecret are ready *)
| AwaitServerHelloDone of session_data * signature_algorithm list option * Cstruct.t * Cstruct.t * hs_log (* server hello done expected, client key exchange and premastersecret are ready *)
| AwaitServerChangeCipherSpec of session_data * crypto_context * Cstruct.t * hs_log (* change cipher spec expected *)
| AwaitServerChangeCipherSpecResume of session_data * crypto_context * crypto_context * hs_log (* change cipher spec expected *)
| AwaitServerFinished of session_data * Cstruct.t * hs_log (* finished expected with a hmac over all handshake packets *)
| AwaitServerFinishedResume of session_data * hs_log (* finished expected with a hmac over all handshake packets *)
| Established (* handshake successfully completed *)
type kdf = {
secret : Cstruct.t ;
cipher : Ciphersuite.ciphersuite13 ;
hash : Mirage_crypto.Hash.hash ;
}
(* TODO needs log of CH..CF for post-handshake auth *)
(* TODO drop master_secret!? *)
type session_data13 = {
common_session_data13 : common_session_data ;
ciphersuite13 : Ciphersuite.ciphersuite13 ;
master_secret : kdf ;
resumption_secret : Cstruct.t ;
state : epoch_state ;
resumed : bool ;
client_app_secret : Cstruct.t ;
server_app_secret : Cstruct.t ;
}
type client13_handshake_state =
| AwaitServerHello13 of client_hello * (group * dh_secret) list * Cstruct.t (* this is for CH1 ~> HRR ~> CH2 <~ WAIT SH *)
| AwaitServerEncryptedExtensions13 of session_data13 * Cstruct.t * Cstruct.t * Cstruct.t
| AwaitServerCertificateRequestOrCertificate13 of session_data13 * Cstruct.t * Cstruct.t * Cstruct.t
| AwaitServerCertificate13 of session_data13 * Cstruct.t * Cstruct.t * signature_algorithm list option * Cstruct.t
| AwaitServerCertificateVerify13 of session_data13 * Cstruct.t * Cstruct.t * signature_algorithm list option * Cstruct.t
| AwaitServerFinished13 of session_data13 * Cstruct.t * Cstruct.t * signature_algorithm list option * Cstruct.t
| Established13
type server13_handshake_state =
| AwaitClientHelloHRR13 (* if we sent out HRR (also to-be-used for tls13-only) *)
| AwaitClientCertificate13 of session_data13 * Cstruct.t * crypto_context * session_ticket option * Cstruct.t
| AwaitClientCertificateVerify13 of session_data13 * Cstruct.t * crypto_context * session_ticket option * Cstruct.t
| AwaitClientFinished13 of Cstruct.t * crypto_context * session_ticket option * Cstruct.t
| AwaitEndOfEarlyData13 of Cstruct.t * crypto_context * crypto_context * session_ticket option * Cstruct.t
| Established13
type handshake_machina_state =
| Client of client_handshake_state
| Server of server_handshake_state
| Client13 of client13_handshake_state
| Server13 of server13_handshake_state
(* state during a handshake, used in the handlers *)
type handshake_state = {
session : [ `TLS of session_data | `TLS13 of session_data13 ] list ;
protocol_version : tls_version ;
early_data_left : int32 ;
machina : handshake_machina_state ; (* state machine state *)
config : Config.config ; (* given config *)
hs_fragment : Cstruct.t ; (* handshake messages can be fragmented, leftover from before *)
}
(* connection state: initially None, after handshake a crypto context *)
type crypto_state = crypto_context option
(* record consisting of a content type and a byte vector *)
type record = Packet.content_type * Cstruct.t
(* response returned by a handler *)
type rec_resp = [
| `Change_enc of crypto_context (* either instruction to change the encryptor to the given one *)
| `Change_dec of crypto_context (* either change the decryptor to the given one *)
| `Record of record (* or a record which should be sent out *)
]
(* return type of handshake handlers *)
type handshake_return = handshake_state * rec_resp list
(* Top level state, encapsulating the entire session. *)
type state = {
handshake : handshake_state ; (* the current handshake state *)
decryptor : crypto_state ; (* the current decryption state *)
encryptor : crypto_state ; (* the current encryption state *)
fragment : Cstruct.t ; (* the leftover fragment from TCP fragmentation *)
}
type error = [
| `AuthenticationFailure of X509.Validation.validation_error
| `NoConfiguredCiphersuite of Ciphersuite.ciphersuite list
| `NoConfiguredVersions of tls_version list
| `NoConfiguredSignatureAlgorithm of signature_algorithm list
| `NoMatchingCertificateFound of string
| `NoCertificateConfigured
| `CouldntSelectCertificate
]
let pp_error ppf = function
| `AuthenticationFailure v ->
Fmt.pf ppf "authentication failure: %a" X509.Validation.pp_validation_error v
| `NoConfiguredCiphersuite cs ->
Fmt.pf ppf "no configured ciphersuite: %a"
Fmt.(list ~sep:(any ", ") Ciphersuite.pp_ciphersuite) cs
| `NoConfiguredVersions vs ->
Fmt.pf ppf "no configured version: %a"
Fmt.(list ~sep:(any ", ") pp_tls_version) vs
| `NoConfiguredSignatureAlgorithm sas ->
Fmt.pf ppf "no configure signature algorithm: %a"
Fmt.(list ~sep:(any ", ") pp_signature_algorithm) sas
| `NoMatchingCertificateFound host ->
Fmt.pf ppf "no matching certificate found for %s" host
| `NoCertificateConfigured -> Fmt.string ppf "no certificate configured"
| `CouldntSelectCertificate -> Fmt.string ppf "couldn't select certificate"
type client_hello_errors = [
| `EmptyCiphersuites
| `NotSetCiphersuites of Packet.any_ciphersuite list
| `NoSupportedCiphersuite of Packet.any_ciphersuite list
| `NotSetExtension of client_extension list
| `NoSignatureAlgorithmsExtension
| `NoGoodSignatureAlgorithms of signature_algorithm list
| `NoKeyShareExtension
| `NoSupportedGroupExtension
| `NotSetSupportedGroup of Packet.named_group list
| `NotSetKeyShare of (Packet.named_group * Cstruct.t) list
| `NotSubsetKeyShareSupportedGroup of Packet.named_group list * (Packet.named_group * Cstruct.t) list
| `Has0rttAfterHRR
| `NoCookie
]
let pp_client_hello_error ppf = function
| `EmptyCiphersuites -> Fmt.string ppf "empty ciphersuites"
| `NotSetCiphersuites cs ->
Fmt.pf ppf "ciphersuites not a set: %a"
Fmt.(list ~sep:(any ", ") Ciphersuite.pp_any_ciphersuite) cs
| `NoSupportedCiphersuite cs ->
Fmt.pf ppf "no supported ciphersuite %a"
Fmt.(list ~sep:(any ", ") Ciphersuite.pp_any_ciphersuite) cs
| `NotSetExtension _ -> Fmt.string ppf "extensions not a set"
| `NoSignatureAlgorithmsExtension ->
Fmt.string ppf "no signature algorithms extension"
| `NoGoodSignatureAlgorithms sas ->
Fmt.pf ppf "no good signature algorithm: %a"
Fmt.(list ~sep:(any ", ") pp_signature_algorithm) sas
| `NoKeyShareExtension -> Fmt.string ppf "no keyshare extension"
| `NoSupportedGroupExtension ->
Fmt.string ppf "no supported group extension"
| `NotSetSupportedGroup groups ->
Fmt.pf ppf "supported groups not a set: %a"
Fmt.(list ~sep:(any ", ") int) (List.map Packet.named_group_to_int groups)
| `NotSetKeyShare ks ->
Fmt.pf ppf "key share not a set: %a"
Fmt.(list ~sep:(any ", ") int)
(List.map (fun (g, _) -> Packet.named_group_to_int g) ks)
| `NotSubsetKeyShareSupportedGroup (ng, ks) ->
Fmt.pf ppf "key share not a subset of supported groups: %a@ keyshare %a"
Fmt.(list ~sep:(any ", ") int) (List.map Packet.named_group_to_int ng)
Fmt.(list ~sep:(any ", ") int)
(List.map (fun (g, _) -> Packet.named_group_to_int g) ks)
| `Has0rttAfterHRR -> Fmt.string ppf "has 0RTT after HRR"
| `NoCookie -> Fmt.string ppf "no cookie"
type fatal = [
| `NoSecureRenegotiation
| `NoSupportedGroup
| `NoVersions of tls_any_version list
| `ReaderError of Reader.error
| `NoCertificateReceived
| `NoCertificateVerifyReceived
| `NotRSACertificate
| `KeyTooSmall
| `SignatureVerificationFailed of string
| `SigningFailed of string
| `BadCertificateChain
| `MACMismatch
| `MACUnderflow
| `RecordOverflow of int
| `UnknownRecordVersion of int * int
| `UnknownContentType of int
| `CannotHandleApplicationDataYet
| `NoHeartbeat
| `BadRecordVersion of tls_any_version
| `BadFinished
| `HandshakeFragmentsNotEmpty
| `InsufficientDH
| `InvalidDH
| `BadECDH of Mirage_crypto_ec.error
| `InvalidRenegotiation
| `InvalidClientHello of client_hello_errors
| `InvalidServerHello
| `InvalidRenegotiationVersion of tls_version
| `InappropriateFallback
| `UnexpectedCCS
| `UnexpectedHandshake of tls_handshake
| `InvalidCertificateUsage
| `InvalidCertificateExtendedUsage
| `InvalidSession
| `NoApplicationProtocol
| `HelloRetryRequest
| `InvalidMessage
| `Toomany0rttbytes
| `MissingContentType
| `Downgrade12
| `Downgrade11
]
let pp_fatal ppf = function
| `NoSecureRenegotiation -> Fmt.string ppf "no secure renegotiation"
| `NoSupportedGroup -> Fmt.string ppf "no supported group"
| `NoVersions vs ->
Fmt.pf ppf "no versions %a" Fmt.(list ~sep:(any ", ") pp_tls_any_version) vs
| `ReaderError re -> Fmt.pf ppf "reader error: %a" Reader.pp_error re
| `NoCertificateReceived -> Fmt.string ppf "no certificate received"
| `NoCertificateVerifyReceived ->
Fmt.string ppf "no certificate verify received"
| `NotRSACertificate -> Fmt.string ppf "not a RSA certificate"
| `KeyTooSmall -> Fmt.string ppf "key too small"
| `SignatureVerificationFailed msg ->
Fmt.pf ppf "signature verification failed: %s" msg
| `SigningFailed msg -> Fmt.pf ppf "signing failed: %s" msg
| `BadCertificateChain -> Fmt.string ppf "bad certificate chain"
| `MACMismatch -> Fmt.string ppf "MAC mismatch"
| `MACUnderflow -> Fmt.string ppf "MAC underflow"
| `RecordOverflow n -> Fmt.pf ppf "record overflow %u" n
| `UnknownRecordVersion (m, n) ->
Fmt.pf ppf "unknown record version %u.%u" m n
| `UnknownContentType c -> Fmt.pf ppf "unknown content type %u" c
| `CannotHandleApplicationDataYet ->
Fmt.string ppf "cannot handle application data yet"
| `NoHeartbeat -> Fmt.string ppf "no heartbeat"
| `BadRecordVersion v ->
Fmt.pf ppf "bad record version %a" pp_tls_any_version v
| `BadFinished -> Fmt.string ppf "bad finished"
| `HandshakeFragmentsNotEmpty ->
Fmt.string ppf "handshake fragments not empty"
| `InsufficientDH -> Fmt.string ppf "insufficient DH"
| `InvalidDH -> Fmt.string ppf "invalid DH"
| `BadECDH e -> Fmt.pf ppf "bad ECDH %a" Mirage_crypto_ec.pp_error e
| `InvalidRenegotiation -> Fmt.string ppf "invalid renegotiation"
| `InvalidClientHello ce ->
Fmt.pf ppf "invalid client hello: %a" pp_client_hello_error ce
| `InvalidServerHello -> Fmt.string ppf "invalid server hello"
| `InvalidRenegotiationVersion v ->
Fmt.pf ppf "invalid renegotiation version %a" pp_tls_version v
| `InappropriateFallback -> Fmt.string ppf "inappropriate fallback"
| `UnexpectedCCS -> Fmt.string ppf "unexpected change cipher spec"
| `UnexpectedHandshake hs ->
Fmt.pf ppf "unexpected handshake %a" pp_handshake hs
| `InvalidCertificateUsage -> Fmt.string ppf "invalid certificate usage"
| `InvalidCertificateExtendedUsage ->
Fmt.string ppf "invalid certificate extended usage"
| `InvalidSession -> Fmt.string ppf "invalid session"
| `NoApplicationProtocol -> Fmt.string ppf "no application protocol"
| `HelloRetryRequest -> Fmt.string ppf "hello retry request"
| `InvalidMessage -> Fmt.string ppf "invalid message"
| `Toomany0rttbytes -> Fmt.string ppf "too many 0RTT bytes"
| `MissingContentType -> Fmt.string ppf "missing content type"
| `Downgrade12 -> Fmt.string ppf "downgrade 1.2"
| `Downgrade11 -> Fmt.string ppf "downgrade 1.1"
type failure = [
| `Error of error
| `Fatal of fatal
]
let pp_failure ppf = function
| `Error e -> pp_error ppf e
| `Fatal f -> pp_fatal ppf f
let common_data_to_epoch common is_server peer_name =
let own_random, peer_random =
if is_server then
common.server_random, common.client_random
else
common.client_random, common.server_random
in
let epoch : epoch_data =
{ state = `Established ;
protocol_version = `TLS_1_0 ;
ciphersuite = `DHE_RSA_WITH_AES_256_CBC_SHA ;
peer_random ;
peer_certificate = common.peer_certificate ;
peer_certificate_chain = common.peer_certificate_chain ;
peer_name ;
trust_anchor = common.trust_anchor ;
own_random ;
own_certificate = common.own_certificate ;
own_private_key = common.own_private_key ;
own_name = common.own_name ;
received_certificates = common.received_certificates ;
master_secret = common.master_secret ;
alpn_protocol = common.alpn_protocol ;
session_id = Cstruct.empty ;
extended_ms = false ;
} in
epoch
let epoch_of_session server peer_name protocol_version = function
| `TLS (session : session_data) ->
let epoch = common_data_to_epoch session.common_session_data server peer_name in
{
epoch with
protocol_version = protocol_version ;
ciphersuite = session.ciphersuite ;
session_id = session.session_id ;
extended_ms = session.extended_ms ;
}
| `TLS13 (session : session_data13) ->
let epoch : epoch_data = common_data_to_epoch session.common_session_data13 server peer_name in
{
epoch with
ciphersuite = (session.ciphersuite13 :> Ciphersuite.ciphersuite) ;
extended_ms = true ; (* RFC 8446, Appendix D, last paragraph *)
state = session.state ;
}
let epoch_of_hs hs =
let server =
match hs.machina with
| Client _ | Client13 _ -> false
| Server _ | Server13 _ -> true
and peer_name = Config.(hs.config.peer_name)
in
match hs.session with
| [] -> None
| session :: _ -> Some (epoch_of_session server peer_name hs.protocol_version session)
| (* Defines all high-level datatypes for the TLS library. It is opaque to clients
of this library, and only used from within the library. *) |
SFTexture_cstub.c |
#include <SFML/Graphics/Texture.h>
#include "sf_caml_incs_c.h"
#include "sf_caml_conv_c.h"
#include "sf_conv_vectors_c.h"
#include "SFTexture_cstub.h"
#include "SFRect_cstub.h"
#include "SFImage_cstub.h"
/* sfTexture */
CAMLprim value
caml_sfTexture_create(value width, value height)
{
sfTexture *tex = sfTexture_create(Long_val(width), Long_val(height));
if (tex == NULL) caml_failwith("SFTexture.create");
return Val_sfTexture(tex);
}
CAMLprim value
caml_sfTexture_destroy(value texture)
{
sfTexture_destroy(SfTexture_val(texture));
return Val_unit;
}
CAMLprim value
caml_sfTexture_createFromFile(value filename, value ml_area, value unit)
{
sfIntRect area;
sfIntRect *area_ptr;
if (ml_area != Val_none) {
SfIntRect_val(&area, Some_val(ml_area));
area_ptr = &area;
} else {
area_ptr = NULL;
}
sfTexture *tex = sfTexture_createFromFile(String_val(filename), area_ptr);
if (tex == NULL) caml_failwith("SFTexture.createFromFile");
return Val_sfTexture(tex);
}
CAMLprim value
caml_sfTexture_createFromMemory(value data, value ml_area, value unit)
{
sfIntRect area;
sfIntRect *area_ptr;
if (ml_area != Val_none) {
SfIntRect_val(&area, Some_val(ml_area));
area_ptr = &area;
} else {
area_ptr = NULL;
}
sfTexture *tex = sfTexture_createFromMemory(
String_val(data), caml_string_length(data), area_ptr);
if (tex == NULL) caml_failwith("SFTexture.createFromMemory");
return Val_sfTexture(tex);
}
/* TODO?
sfTexture* sfTexture_createFromStream(
sfInputStream* stream, const sfIntRect* area);
*/
CAMLprim value
caml_sfTexture_createFromImage(value image, value ml_area, value unit)
{
sfIntRect area;
sfIntRect *area_ptr;
if (ml_area != Val_none) {
SfIntRect_val(&area, Some_val(ml_area));
area_ptr = &area;
} else {
area_ptr = NULL;
}
sfTexture *tex = sfTexture_createFromImage(SfImage_val_u(image), area_ptr);
if (tex == NULL) caml_failwith("SFTexture.createFromImage");
return Val_sfTexture(tex);
}
CAMLprim value
caml_sfTexture_copy(value texture)
{
sfTexture *tex = sfTexture_copy(SfTexture_val(texture));
if (tex == NULL) caml_failwith("SFTexture.copy");
return Val_sfTexture(tex);
}
CAMLprim value
caml_sfTexture_getSize(value texture)
{
sfVector2u size = sfTexture_getSize(SfTexture_val(texture));
return Val_sfVector2u(&size);
}
CAMLprim value
caml_sfTexture_copyToImage(value texture)
{
sfImage *img = sfTexture_copyToImage(SfTexture_val(texture));
if (!img) caml_failwith("SFTexture.copyToImage");
return caml_copy_sfImage(img); // XXX TODO: test and debug me!
}
/* TODO
void sfTexture_updateFromPixels(sfTexture* texture, const sfUint8* pixels,
unsigned int width, unsigned int height, unsigned int x, unsigned int y);
void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image,
unsigned int x, unsigned int y);
void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window,
unsigned int x, unsigned int y);
void sfTexture_updateFromRenderWindow(sfTexture* texture,
const sfRenderWindow* renderWindow, unsigned int x, unsigned int y);
*/
CAMLprim value
caml_sfTexture_bind(value texture)
{
sfTexture_bind(SfTexture_val(texture));
return Val_unit;
}
CAMLprim value
caml_sfTexture_setSmooth(value texture, value smooth)
{
sfTexture_setSmooth(SfTexture_val(texture), Bool_val(smooth));
return Val_unit;
}
CAMLprim value
caml_sfTexture_isSmooth(value texture)
{
return Val_bool(sfTexture_isSmooth(SfTexture_val(texture)));
}
CAMLprim value
caml_sfTexture_setRepeated(value texture, value repeated)
{
sfTexture_setRepeated(SfTexture_val(texture), Bool_val(repeated));
return Val_unit;
}
CAMLprim value
caml_sfTexture_isRepeated(value texture)
{
return Val_bool(sfTexture_isRepeated(SfTexture_val(texture)));
}
CAMLprim value
caml_sfTexture_getMaximumSize(value unit)
{
unsigned int size = sfTexture_getMaximumSize();
return Val_long(size);
}
/* vim: sw=4 sts=4 ts=4 et
*/
| /*
* OCaml-SFML - OCaml bindings for the SFML library.
* Copyright (C) 2010 Florent Monnier <monnier.florent(_)gmail.com>
*
* This software is provided 'as-is', without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from the
* use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented;
* you must not claim that you wrote the original software.
* If you use this software in a product, an acknowledgment
* in the product documentation would be appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such,
* and must not be misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*/ |
util.ml | let parse_env_line l =
try Scanf.sscanf l "%[^=]=%S" (fun name value -> Some(name,value))
with _ -> None
let with_ic file f =
let ic = open_in file in
try
let rc = f ic in
close_in ic;
rc
with e -> close_in ic; raise e
let getenv_from_file name =
let base = Filename.dirname Sys.executable_name in
try
with_ic (base ^ "/coq_environment.txt") (fun ic ->
let rec find () =
let l = input_line ic in
match parse_env_line l with
| Some(n,v) when n = name -> v
| _ -> find ()
in
find ())
with
| Sys_error s -> raise Not_found
| End_of_file -> raise Not_found
let system_getenv name =
try Sys.getenv name with Not_found -> getenv_from_file name
let getenv_else s dft = try system_getenv s with Not_found -> dft ()
(** Add a local installation suffix (unless the suffix is itself
absolute in which case the prefix does not matter) *)
let use_suffix prefix suffix =
if String.length suffix > 0 && suffix.[0] = '/'
then suffix
else Filename.concat prefix suffix
let canonical_path_name p =
let current = Sys.getcwd () in
try
Sys.chdir p;
let p' = Sys.getcwd () in
Sys.chdir current;
p'
with Sys_error _ ->
(* We give up to find a canonical name and just simplify it... *)
Filename.concat current p
let coqbin =
canonical_path_name (Filename.dirname Sys.executable_name)
(** The following only makes sense when executables are running from
source tree (e.g. during build or in local mode). *)
let coqroot =
Filename.dirname coqbin
(** [check_file_else ~dir ~file oth] checks if [file] exists in
the installation directory [dir] given relatively to [coqroot],
which maybe has been relocated.
If the check fails, then [oth ()] is evaluated.
Using file system equality seems well enough for this heuristic *)
let check_file_else ~dir ~file oth =
let path = use_suffix coqroot dir in
if Sys.file_exists (Filename.concat path file) then path else oth ()
| (************************************************************************)
(* * The Coq Proof Assistant / The Coq Development Team *)
(* v * Copyright INRIA, CNRS and contributors *)
(* <O___,, * (see version control and CREDITS file for authors & dates) *)
(* \VV/ **************************************************************)
(* // * This file is distributed under the terms of the *)
(* * GNU Lesser General Public License Version 2.1 *)
(* * (see LICENSE file for the text of the license) *)
(************************************************************************)
|
example.ml |
let main () =
let points = Genspir.genspir_cartesian (int_of_string (Sys.argv.(1))) in
List.iter
(fun (x, y, z) -> Printf.printf "%f %f %f\n" x y z)
points
;;
main()
| (* Copyright (c) 2013, Zhang Initiative Research Unit,
* Advance Science Institute, RIKEN
* 2-1 Hirosawa, Wako, Saitama 351-0198, Japan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *) |
bootstrap_storage.mli | val init :
Raw_context.t ->
typecheck:(Raw_context.t ->
Script_repr.t ->
( (Script_repr.t * Contract_storage.big_map_diff option)
* Raw_context.t )
tzresult
Lwt.t) ->
?ramp_up_cycles:int ->
?no_reward_cycles:int ->
Parameters_repr.bootstrap_account list ->
Parameters_repr.bootstrap_contract list ->
Raw_context.t tzresult Lwt.t
val cycle_end : Raw_context.t -> Cycle_repr.t -> Raw_context.t tzresult Lwt.t
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
sigset.ml |
open PosixTypes
open Ctypes
open Foreign
type t = sigset_t ptr
let t = ptr sigset_t
(* This function initializes the signal set set to exclude all of the defined
signals. It always returns 0. *)
let sigemptyset = foreign "sigemptyset" (ptr sigset_t @-> returning int)
let empty () =
let setp = allocate_n ~count:1 sigset_t in begin
ignore (sigemptyset setp);
setp
end
(* This function initializes the signal set set to include all of the defined
signals. Again, the return value is 0. *)
let sigfillset = foreign "sigfillset" (ptr sigset_t @-> returning int)
let full () =
let setp = allocate_n ~count:1 sigset_t in begin
ignore (sigfillset setp);
setp
end
(* This function adds the signal signum to the signal set set. All sigaddset
does is modify set; it does not block or unblock any signals.
The return value is 0 on success and -1 on failure. The following errno
error condition is defined for this function:
EINVAL The signum argument doesn't specify a valid signal.
*)
let sigaddset = foreign "sigaddset" ~check_errno:true
(ptr sigset_t @-> int @-> returning int)
let add set signal = ignore (sigaddset set signal)
(* This function removes the signal signum from the signal set set. All
sigdelset does is modify set; it does not block or unblock any signals.
The return value and error conditions are the same as for
sigaddset. *)
let sigdelset = foreign "sigdelset" ~check_errno:true
(ptr sigset_t @-> int @-> returning int)
let del set signal = ignore (sigdelset set signal)
(* The sigismember function tests whether the signal signum is a member of the
signal set set. It returns 1 if the signal is in the set, 0 if not, and -1 if
there is an error.
The following errno error condition is defined for this function:
EINVAL The signum argument doesn't specify a valid signal.
*)
let sigismember = foreign "sigismember" ~check_errno:true
(ptr sigset_t @-> int @-> returning int)
let mem set signal = sigismember set signal <> 0
| (*
* Copyright (c) 2013 Jeremy Yallop.
*
* This file is distributed under the terms of the MIT License.
* See the file LICENSE for details.
*) |
fun.mli |
external id : 'a -> 'a = "%identity"
val const : 'a -> 'b -> 'a
val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
val negate : ('a -> bool) -> 'a -> bool
val protect : finally:(unit -> unit) -> (unit -> 'a) -> 'a
exception Finally_raised of exn
| |
sc_rollup_storage.ml | type error +=
| (* `Temporary *) Sc_rollup_already_staked
| (* `Temporary *) Sc_rollup_disputed
| (* `Temporary *) Sc_rollup_does_not_exist of Sc_rollup_repr.t
| (* `Temporary *) Sc_rollup_no_conflict
| (* `Temporary *) Sc_rollup_no_stakers
| (* `Temporary *) Sc_rollup_not_staked
| (* `Temporary *) Sc_rollup_not_staked_on_lcc
| (* `Temporary *) Sc_rollup_parent_not_lcc
| (* `Temporary *) Sc_rollup_remove_lcc
| (* `Temporary *) Sc_rollup_staker_backtracked
| (* `Temporary *) Sc_rollup_too_far_ahead
| (* `Temporary *) Sc_rollup_too_recent
| (* `Temporary *)
Sc_rollup_unknown_commitment of
Sc_rollup_repr.Commitment_hash.t
| (* `Temporary *) Sc_rollup_bad_inbox_level
| (* `Temporary *) Sc_rollup_max_number_of_available_messages_reached
let () =
register_error_kind
`Temporary
~id:"Sc_rollup_max_number_of_available_messages_reached"
~title:"Maximum number of available messages reached"
~description:"Maximum number of available messages reached"
Data_encoding.unit
(function
| Sc_rollup_max_number_of_available_messages_reached -> Some ()
| _ -> None)
(fun () -> Sc_rollup_max_number_of_available_messages_reached) ;
let description = "Already staked." in
register_error_kind
`Temporary
~id:"Sc_rollup_already_staked"
~title:"Already staked"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_already_staked -> Some () | _ -> None)
(fun () -> Sc_rollup_already_staked) ;
let description = "Attempted to cement a disputed commitment." in
register_error_kind
`Temporary
~id:"Sc_rollup_disputed"
~title:"Commitment disputed"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_disputed -> Some () | _ -> None)
(fun () -> Sc_rollup_disputed) ;
let description = "Attempted to use a rollup that has not been originated." in
register_error_kind
`Temporary
~id:"Sc_rollup_does_not_exist"
~title:"Rollup does not exist"
~description
~pp:(fun ppf x ->
Format.fprintf ppf "Rollup %a does not exist" Sc_rollup_repr.pp x)
Data_encoding.(obj1 (req "rollup" Sc_rollup_repr.encoding))
(function Sc_rollup_does_not_exist x -> Some x | _ -> None)
(fun x -> Sc_rollup_does_not_exist x) ;
let description = "No conflict." in
register_error_kind
`Temporary
~id:"Sc_rollup_no_conflict"
~title:"No conflict"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_no_conflict -> Some () | _ -> None)
(fun () -> Sc_rollup_no_conflict) ;
let description = "No stakers." in
register_error_kind
`Temporary
~id:"Sc_rollup_no_stakers"
~title:"No stakers"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_no_stakers -> Some () | _ -> None)
(fun () -> Sc_rollup_no_stakers) ;
let description = "Unknown staker." in
register_error_kind
`Temporary
~id:"Sc_rollup_not_staked"
~title:"Unknown staker"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_not_staked -> Some () | _ -> None)
(fun () -> Sc_rollup_not_staked) ;
let description =
"Attempted to withdraw while not staked on the last cemented commitment."
in
register_error_kind
`Temporary
~id:"Sc_rollup_not_staked_on_lcc"
~title:"Rollup not staked on LCC"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_not_staked_on_lcc -> Some () | _ -> None)
(fun () -> Sc_rollup_not_staked_on_lcc) ;
let description = "Parent is not cemented." in
register_error_kind
`Temporary
~id:"Sc_rollup_parent_not_lcc"
~title:"Parent not cemented"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_parent_not_lcc -> Some () | _ -> None)
(fun () -> Sc_rollup_parent_not_lcc) ;
let description = "Can not remove a cemented commitment." in
register_error_kind
`Temporary
~id:"Sc_rollup_remove_lcc"
~title:"Can not remove cemented"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_remove_lcc -> Some () | _ -> None)
(fun () -> Sc_rollup_remove_lcc) ;
let description = "Staker backtracked." in
register_error_kind
`Temporary
~id:"Sc_rollup_staker_backtracked"
~title:"Staker backtracked"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_staker_backtracked -> Some () | _ -> None)
(fun () -> Sc_rollup_staker_backtracked) ;
let description =
"Commitment is too far ahead of the last cemented commitment."
in
register_error_kind
`Temporary
~id:"Sc_rollup_too_far_ahead"
~title:"Commitment too far ahead"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_too_far_ahead -> Some () | _ -> None)
(fun () -> Sc_rollup_too_far_ahead) ;
let description =
"Attempted to cement a commitment before its refutation deadline."
in
register_error_kind
`Temporary
~id:"Sc_rollup_too_recent"
~title:"Commitment too recent"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_too_recent -> Some () | _ -> None)
(fun () -> Sc_rollup_too_recent) ;
let description = "Unknown commitment." in
register_error_kind
`Temporary
~id:"Sc_rollup_unknown_commitment"
~title:"Rollup does not exist"
~description
~pp:(fun ppf x ->
Format.fprintf
ppf
"Commitment %a does not exist"
Sc_rollup_repr.Commitment_hash.pp
x)
Data_encoding.(
obj1 (req "commitment" Sc_rollup_repr.Commitment_hash.encoding))
(function Sc_rollup_unknown_commitment x -> Some x | _ -> None)
(fun x -> Sc_rollup_unknown_commitment x) ;
let description = "Attempted to commit to a bad inbox level." in
register_error_kind
`Temporary
~id:"Sc_rollup_bad_inbox_level"
~title:"Committed too soon"
~description
~pp:(fun ppf () -> Format.fprintf ppf "%s" description)
Data_encoding.empty
(function Sc_rollup_bad_inbox_level -> Some () | _ -> None)
(fun () -> Sc_rollup_bad_inbox_level) ;
()
module Store = Storage.Sc_rollup
module Commitment = Sc_rollup_repr.Commitment
module Commitment_hash = Sc_rollup_repr.Commitment_hash
let originate ctxt ~kind ~boot_sector =
Raw_context.increment_origination_nonce ctxt >>?= fun (ctxt, nonce) ->
let level = Raw_context.current_level ctxt in
Sc_rollup_repr.Address.from_nonce nonce >>?= fun address ->
Storage.Sc_rollup.PVM_kind.add ctxt address kind >>= fun ctxt ->
Storage.Sc_rollup.Initial_level.add
ctxt
address
(Level_storage.current ctxt).level
>>= fun ctxt ->
Storage.Sc_rollup.Boot_sector.add ctxt address boot_sector >>= fun ctxt ->
let inbox = Sc_rollup_inbox_repr.empty address level.level in
Storage.Sc_rollup.Inbox.init ctxt address inbox >>=? fun (ctxt, size_diff) ->
Store.Last_cemented_commitment.init ctxt address Commitment_hash.zero
>>=? fun (ctxt, lcc_size_diff) ->
Store.Staker_count.init ctxt address 0l >>=? fun (ctxt, stakers_size_diff) ->
let addresses_size = 2 * Sc_rollup_repr.Address.size in
let stored_kind_size = 2 (* because tag_size of kind encoding is 16bits. *) in
let boot_sector_size =
Data_encoding.Binary.length Data_encoding.string boot_sector
in
let origination_size = Constants_storage.sc_rollup_origination_size ctxt in
let size =
Z.of_int
(origination_size + stored_kind_size + boot_sector_size + addresses_size
+ size_diff + lcc_size_diff + stakers_size_diff)
in
return (address, size, ctxt)
let kind ctxt address = Storage.Sc_rollup.PVM_kind.find ctxt address
let last_cemented_commitment ctxt rollup =
let open Lwt_tzresult_syntax in
let* (ctxt, res) = Store.Last_cemented_commitment.find ctxt rollup in
match res with
| None -> fail (Sc_rollup_does_not_exist rollup)
| Some lcc -> return (lcc, ctxt)
(** Try to consume n messages. *)
let consume_n_messages ctxt rollup n =
let open Lwt_tzresult_syntax in
let* (ctxt, inbox) = Storage.Sc_rollup.Inbox.get ctxt rollup in
Sc_rollup_inbox_repr.consume_n_messages n inbox >>?= function
| None -> return ctxt
| Some inbox ->
let* (ctxt, size) = Storage.Sc_rollup.Inbox.update ctxt rollup inbox in
assert (Compare.Int.(size <= 0)) ;
return ctxt
let inbox ctxt rollup =
let open Lwt_tzresult_syntax in
let* (ctxt, res) = Storage.Sc_rollup.Inbox.find ctxt rollup in
match res with
| None -> fail (Sc_rollup_does_not_exist rollup)
| Some inbox -> return (inbox, ctxt)
let assert_inbox_size_ok ctxt next_size =
let max_size = Constants_storage.sc_rollup_max_available_messages ctxt in
fail_unless
Compare.Z.(next_size <= Z.of_int max_size)
Sc_rollup_max_number_of_available_messages_reached
let add_messages ctxt rollup messages =
let open Lwt_tzresult_syntax in
let open Raw_context in
inbox ctxt rollup >>=? fun (inbox, ctxt) ->
let next_size =
Z.add
(Sc_rollup_inbox_repr.number_of_available_messages inbox)
(Z.of_int (List.length messages))
in
assert_inbox_size_ok ctxt next_size >>=? fun () ->
let*? (current_messages, ctxt) =
Sc_rollup_in_memory_inbox.current_messages ctxt rollup
in
let {Level_repr.level; _} = Raw_context.current_level ctxt in
(*
Notice that the protocol is forgetful: it throws away the inbox
history. On the contrary, the history is stored by the rollup
node to produce inclusion proofs when needed.
*)
let* (current_messages, inbox) =
Sc_rollup_inbox_repr.(
add_messages_no_history inbox level messages current_messages)
in
let*? ctxt =
Sc_rollup_in_memory_inbox.set_current_messages ctxt rollup current_messages
in
Storage.Sc_rollup.Inbox.update ctxt rollup inbox >>=? fun (ctxt, size) ->
return (inbox, Z.of_int size, ctxt)
(* This function is called in other functions in the module only after they have
checked for the existence of the rollup, and therefore it is not necessary
for it to check for the existence of the rollup again. It is not directly
exposed by the module. Instead, a different public function [get_commitment]
is provided, which checks for the existence of [rollup] before calling
[get_commitment_internal]. *)
let get_commitment_internal ctxt rollup commitment =
let open Lwt_tzresult_syntax in
let* (ctxt, res) = Store.Commitments.find (ctxt, rollup) commitment in
match res with
| None -> fail (Sc_rollup_unknown_commitment commitment)
| Some commitment -> return (commitment, ctxt)
let get_commitment ctxt rollup commitment =
let open Lwt_tzresult_syntax in
(* Assert that a last cemented commitment exists. *)
let* (_lcc, ctxt) = last_cemented_commitment ctxt rollup in
get_commitment_internal ctxt rollup commitment
let get_predecessor ctxt rollup node =
let open Lwt_tzresult_syntax in
let* (commitment, ctxt) = get_commitment_internal ctxt rollup node in
return (commitment.predecessor, ctxt)
let find_staker ctxt rollup staker =
let open Lwt_tzresult_syntax in
let* (ctxt, res) = Store.Stakers.find (ctxt, rollup) staker in
match res with
| None -> fail Sc_rollup_not_staked
| Some branch -> return (branch, ctxt)
let modify_staker_count ctxt rollup f =
let open Lwt_tzresult_syntax in
let* (ctxt, maybe_count) = Store.Staker_count.find ctxt rollup in
let count = Option.value ~default:0l maybe_count in
let* (ctxt, size_diff, _was_bound) =
Store.Staker_count.add ctxt rollup (f count)
in
assert (Compare.Int.(size_diff = 0)) ;
return ctxt
let get_commitment_stake_count ctxt rollup node =
let open Lwt_tzresult_syntax in
let* (ctxt, maybe_staked_on_commitment) =
Store.Commitment_stake_count.find (ctxt, rollup) node
in
return (Option.value ~default:0l maybe_staked_on_commitment, ctxt)
(** [set_commitment_added ctxt rollup node current] sets the commitment
addition time of [node] to [current] iff the commitment time was
not previously set, and leaves it unchanged otherwise.
*)
let set_commitment_added ctxt rollup node new_value =
let open Lwt_tzresult_syntax in
let* (ctxt, res) = Store.Commitment_added.find (ctxt, rollup) node in
let new_value =
match res with None -> new_value | Some old_value -> old_value
in
let* (ctxt, size_diff, _was_bound) =
Store.Commitment_added.add (ctxt, rollup) node new_value
in
return (size_diff, ctxt)
let deallocate ctxt rollup node =
let open Lwt_tzresult_syntax in
if Commitment_hash.(node = zero) then return ctxt
else
let* (ctxt, _size_freed) =
Store.Commitments.remove_existing (ctxt, rollup) node
in
let* (ctxt, _size_freed) =
Store.Commitment_added.remove_existing (ctxt, rollup) node
in
let* (ctxt, _size_freed) =
Store.Commitment_stake_count.remove_existing (ctxt, rollup) node
in
return ctxt
let modify_commitment_stake_count ctxt rollup node f =
let open Lwt_tzresult_syntax in
let* (count, ctxt) = get_commitment_stake_count ctxt rollup node in
let new_count = f count in
let* (ctxt, size_diff, _was_bound) =
Store.Commitment_stake_count.add (ctxt, rollup) node new_count
in
return (new_count, size_diff, ctxt)
let increase_commitment_stake_count ctxt rollup node =
let open Lwt_tzresult_syntax in
let* (_new_count, size_diff, ctxt) =
modify_commitment_stake_count ctxt rollup node Int32.succ
in
return (size_diff, ctxt)
let decrease_commitment_stake_count ctxt rollup node =
let open Lwt_tzresult_syntax in
let* (new_count, _size_diff, ctxt) =
modify_commitment_stake_count ctxt rollup node Int32.pred
in
if Compare.Int32.(new_count <= 0l) then deallocate ctxt rollup node
else return ctxt
let deposit_stake ctxt rollup staker =
let open Lwt_tzresult_syntax in
let* (lcc, ctxt) = last_cemented_commitment ctxt rollup in
let* (ctxt, res) = Store.Stakers.find (ctxt, rollup) staker in
match res with
| None ->
(* TODO: https://gitlab.com/tezos/tezos/-/issues/2449
We should lock stake here, and fail if there aren't enough funds.
*)
let* (ctxt, _size) = Store.Stakers.init (ctxt, rollup) staker lcc in
let* ctxt = modify_staker_count ctxt rollup Int32.succ in
return ctxt
| Some _ -> fail Sc_rollup_already_staked
let withdraw_stake ctxt rollup staker =
let open Lwt_tzresult_syntax in
let* (lcc, ctxt) = last_cemented_commitment ctxt rollup in
let* (ctxt, res) = Store.Stakers.find (ctxt, rollup) staker in
match res with
| None -> fail Sc_rollup_not_staked
| Some staked_on_commitment ->
if Commitment_hash.(staked_on_commitment = lcc) then
(* TODO: https://gitlab.com/tezos/tezos/-/issues/2449
We should refund stake here.
*)
let* (ctxt, _size_freed) =
Store.Stakers.remove_existing (ctxt, rollup) staker
in
let* ctxt = modify_staker_count ctxt rollup Int32.pred in
modify_staker_count ctxt rollup Int32.pred
else fail Sc_rollup_not_staked_on_lcc
let assert_commitment_not_too_far_ahead ctxt rollup lcc commitment =
let open Lwt_tzresult_syntax in
let* (ctxt, min_level) =
if Commitment_hash.(lcc = zero) then
let* level = Store.Initial_level.get ctxt rollup in
return (ctxt, level)
else
let* (lcc, ctxt) = get_commitment_internal ctxt rollup lcc in
return (ctxt, Commitment.(lcc.inbox_level))
in
let max_level = Commitment.(commitment.inbox_level) in
if
let sc_rollup_max_lookahead =
Constants_storage.sc_rollup_max_lookahead_in_blocks ctxt
in
Compare.Int32.(
sc_rollup_max_lookahead < Raw_level_repr.diff max_level min_level)
then fail Sc_rollup_too_far_ahead
else return ctxt
(** Enfore that a commitment's inbox level increases by an exact fixed amount over its predecessor.
This property is used in several places - not obeying it causes severe breakage.
*)
let assert_commitment_frequency ctxt rollup commitment =
let open Lwt_tzresult_syntax in
let pred = Commitment.(commitment.predecessor) in
let* (ctxt, pred_level) =
if Commitment_hash.(pred = zero) then
let* level = Store.Initial_level.get ctxt rollup in
return (ctxt, level)
else
let* (pred, ctxt) =
get_commitment_internal ctxt rollup commitment.predecessor
in
return (ctxt, Commitment.(pred.inbox_level))
in
(* We want to check the following inequalities on [commitment.inbox_level],
[commitment.predecessor.inbox_level] and the constant [sc_rollup_commitment_frequency].
- Greater-than-or-equal (>=), to ensure inbox_levels are monotonically
increasing. along each branch of commitments. Together with
[assert_commitment_not_too_far_ahead] this is sufficient to limit the
depth of the commitment tree, which is also the number commitments stored
per staker. This constraint must be enforced at submission time.
- Equality (=), so that that L2 blocks are produced at a regular rate. This
ensures that there is only ever one branch of correct commitments,
simplifying refutation logic. This could also be enforced at refutation time
rather than submission time, but doing it here works too.
Because [a >= b && a = b] is equivalent to [a = b], we can the latter as
an optimization.
*)
let sc_rollup_commitment_frequency =
Constants_storage.sc_rollup_commitment_frequency_in_blocks ctxt
in
if
Raw_level_repr.(
commitment.inbox_level = add pred_level sc_rollup_commitment_frequency)
then return ctxt
else fail Sc_rollup_bad_inbox_level
(** Check invariants on [inbox_level], enforcing overallocation of storage and
regularity of block prorudction.
The constants used by [assert_refine_conditions_met] must be chosen such
that the maximum cost of storage allocated by each staker at most the size
of their deposit.
*)
let assert_refine_conditions_met ctxt rollup lcc commitment =
let open Lwt_tzresult_syntax in
let* ctxt = assert_commitment_not_too_far_ahead ctxt rollup lcc commitment in
assert_commitment_frequency ctxt rollup commitment
let refine_stake ctxt rollup staker commitment =
let open Lwt_tzresult_syntax in
let* (lcc, ctxt) = last_cemented_commitment ctxt rollup in
let* (staked_on, ctxt) = find_staker ctxt rollup staker in
let* ctxt = assert_refine_conditions_met ctxt rollup lcc commitment in
let new_hash = Commitment.hash commitment in
(* TODO: https://gitlab.com/tezos/tezos/-/issues/2559
Add a test checking that L2 nodes can catch up after going offline. *)
let rec go node ctxt =
(* WARNING: Do NOT reorder this sequence of ifs.
we must check for staked_on before LCC, since refining
from the LCC to another commit is a valid operation. *)
if Commitment_hash.(node = staked_on) then (
(* Previously staked commit found:
Insert new commitment if not existing *)
let* (ctxt, commitment_size_diff, _was_bound) =
Store.Commitments.add (ctxt, rollup) new_hash commitment
in
let level = (Raw_context.current_level ctxt).level in
let* (commitment_added_size_diff, ctxt) =
set_commitment_added ctxt rollup new_hash level
in
let* (ctxt, staker_count_diff) =
Store.Stakers.update (ctxt, rollup) staker new_hash
in
let* (stake_count_size_diff, ctxt) =
increase_commitment_stake_count ctxt rollup new_hash
in
(* WARNING: [commitment_storage_size] is a defined constant, and used
to set a bound on the relationship between [max_lookahead],
[commitment_frequency] and [stake_amount]. Be careful changing this
calculation. *)
let size_diff =
commitment_size_diff + commitment_added_size_diff
+ stake_count_size_diff + staker_count_diff
in
let expected_size_diff =
Constants_storage.sc_rollup_commitment_storage_size_in_bytes ctxt
in
(* First submission adds [sc_rollup_commitment_storage_size_in_bytes] to storage.
Later submission adds 0 due to content-addressing. *)
assert (Compare.Int.(size_diff = 0 || size_diff = expected_size_diff)) ;
return (new_hash, ctxt) (* See WARNING above. *))
else if Commitment_hash.(node = lcc) then
(* We reached the LCC, but [staker] is not staked directly on it.
Thus, we backtracked. Note that everyone is staked indirectly on
the LCC. *)
fail Sc_rollup_staker_backtracked
else
let* (pred, ctxt) = get_predecessor ctxt rollup node in
let* (_size, ctxt) = increase_commitment_stake_count ctxt rollup node in
(go [@ocaml.tailcall]) pred ctxt
in
go Commitment.(commitment.predecessor) ctxt
let publish_commitment ctxt rollup staker commitment =
let open Lwt_tzresult_syntax in
let* (ctxt, res) = Store.Stakers.find (ctxt, rollup) staker in
match res with
| None ->
let* ctxt = deposit_stake ctxt rollup staker in
refine_stake ctxt rollup staker commitment
| Some _ -> refine_stake ctxt rollup staker commitment
let cement_commitment ctxt rollup new_lcc =
let open Lwt_tzresult_syntax in
let refutation_deadline_blocks =
Constants_storage.sc_rollup_challenge_window_in_blocks ctxt
in
(* Calling [last_final_commitment] first to trigger failure in case of
non-existing rollup. *)
let* (old_lcc, ctxt) = last_cemented_commitment ctxt rollup in
(* Get is safe, as [Stakers_size] is initialized on origination. *)
let* (ctxt, total_staker_count) = Store.Staker_count.get ctxt rollup in
if Compare.Int32.(total_staker_count <= 0l) then fail Sc_rollup_no_stakers
else
let* (new_lcc_commitment, ctxt) =
get_commitment_internal ctxt rollup new_lcc
in
let* (ctxt, new_lcc_added) =
Store.Commitment_added.get (ctxt, rollup) new_lcc
in
if Commitment_hash.(new_lcc_commitment.predecessor <> old_lcc) then
fail Sc_rollup_parent_not_lcc
else
let* (new_lcc_stake_count, ctxt) =
get_commitment_stake_count ctxt rollup new_lcc
in
if Compare.Int32.(total_staker_count <> new_lcc_stake_count) then
fail Sc_rollup_disputed
else if
let level = (Raw_context.current_level ctxt).level in
Raw_level_repr.(level < add new_lcc_added refutation_deadline_blocks)
then fail Sc_rollup_too_recent
else
(* update LCC *)
let* (ctxt, lcc_size_diff) =
Store.Last_cemented_commitment.update ctxt rollup new_lcc
in
assert (Compare.Int.(lcc_size_diff = 0)) ;
(* At this point we know all stakers are implicitly staked
on the new LCC, and no one is directly staked on the old LCC. We
can safely deallocate the old LCC.
*)
let* ctxt = deallocate ctxt rollup old_lcc in
consume_n_messages
ctxt
rollup
(Int32.to_int
@@ Sc_rollup_repr.Number_of_messages.to_int32
new_lcc_commitment.number_of_messages)
type conflict_point = Commitment_hash.t * Commitment_hash.t
(** [goto_inbox_level ctxt rollup inbox_level commit] Follows the predecessors of [commit] until it
arrives at the exact [inbox_level]. The result is the commit hash at the given inbox level. *)
let goto_inbox_level ctxt rollup inbox_level commit =
let open Lwt_tzresult_syntax in
let rec go ctxt commit =
let* (info, ctxt) = get_commitment_internal ctxt rollup commit in
if Raw_level_repr.(info.Commitment.inbox_level <= inbox_level) then (
(* Assert that we're exactly at that level. If this isn't the case, we're most likely in a
situation where inbox levels are inconsistent. *)
assert (Raw_level_repr.(info.inbox_level = inbox_level)) ;
return (commit, ctxt))
else (go [@ocaml.tailcall]) ctxt info.predecessor
in
go ctxt commit
let get_conflict_point ctxt rollup staker1 staker2 =
let open Lwt_tzresult_syntax in
(* Ensure the LCC is set. *)
let* (lcc, ctxt) = last_cemented_commitment ctxt rollup in
(* Find out on which commitments the competitors are staked. *)
let* (commit1, ctxt) = find_staker ctxt rollup staker1 in
let* (commit2, ctxt) = find_staker ctxt rollup staker2 in
let* () =
fail_when
Commitment_hash.(
(* If PVM is in pre-boot state, there might be stakes on the zero commitment. *)
commit1 = zero || commit2 = zero
(* If either commit is the LCC, that also means there can't be a conflict. *)
|| commit1 = lcc
|| commit2 = lcc)
Sc_rollup_no_conflict
in
let* (commit1_info, ctxt) = get_commitment_internal ctxt rollup commit1 in
let* (commit2_info, ctxt) = get_commitment_internal ctxt rollup commit2 in
(* Make sure that both commits are at the same inbox level. In case they are not move the commit
that is farther ahead to the exact inbox level of the other.
We do this instead of an alternating traversal of either commit to ensure the we can detect
wonky inbox level increases. For example, if the inbox levels decrease in different intervals
between commits for either history, we risk going past the conflict point and accidentally
determined that the commits are not in conflict by joining at the same commit. *)
let target_inbox_level =
Raw_level_repr.min commit1_info.inbox_level commit2_info.inbox_level
in
let* (commit1, ctxt) =
goto_inbox_level ctxt rollup target_inbox_level commit1
in
let* (commit2, ctxt) =
goto_inbox_level ctxt rollup target_inbox_level commit2
in
(* The inbox level of a commitment increases by a fixed amount over the preceding commitment.
We use this fact in the following to efficiently traverse both commitment histories towards
the conflict points. *)
let rec traverse_in_parallel ctxt commit1 commit2 =
if Commitment_hash.(commit1 = commit2) then
(* This case will most dominantly happen when either commit is part of the other's history.
It occurs when the commit that is farther ahead gets dereferenced to its predecessor often
enough to land at the other commit. *)
fail Sc_rollup_no_conflict
else
let* (commit1_info, ctxt) = get_commitment_internal ctxt rollup commit1 in
let* (commit2_info, ctxt) = get_commitment_internal ctxt rollup commit2 in
assert (
Raw_level_repr.(commit1_info.inbox_level = commit2_info.inbox_level)) ;
if Commitment_hash.(commit1_info.predecessor = commit2_info.predecessor)
then
(* Same predecessor means we've found the conflict points. *)
return ((commit1, commit2), ctxt)
else
(* Different predecessors means they run in parallel. *)
(traverse_in_parallel [@ocaml.tailcall])
ctxt
commit1_info.predecessor
commit2_info.predecessor
in
traverse_in_parallel ctxt commit1 commit2
let remove_staker ctxt rollup staker =
let open Lwt_tzresult_syntax in
let* (lcc, ctxt) = last_cemented_commitment ctxt rollup in
let* (ctxt, res) = Store.Stakers.find (ctxt, rollup) staker in
match res with
| None -> fail Sc_rollup_not_staked
| Some staked_on ->
if Commitment_hash.(staked_on = lcc) then fail Sc_rollup_remove_lcc
else
let* (ctxt, _size_diff) =
Store.Stakers.remove_existing (ctxt, rollup) staker
in
let* ctxt = modify_staker_count ctxt rollup Int32.pred in
let rec go node ctxt =
if Commitment_hash.(node = lcc) then return ctxt
else
let* (pred, ctxt) = get_predecessor ctxt rollup node in
let* ctxt = decrease_commitment_stake_count ctxt rollup node in
(go [@ocaml.tailcall]) pred ctxt
in
go staked_on ctxt
let list ctxt = Storage.Sc_rollup.PVM_kind.keys ctxt >|= Result.return
let initial_level ctxt rollup =
let open Lwt_tzresult_syntax in
let* level = Storage.Sc_rollup.Initial_level.find ctxt rollup in
match level with
| None -> fail (Sc_rollup_does_not_exist rollup)
| Some level -> return level
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2021 Nomadic Labs <contact@nomadic-labs.com> *)
(* Copyright (c) 2022 TriliTech <contact@trili.tech> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
testing.ml | (* Testing auxiliaries. *)
open Scanf;;
let all_tests_ok = ref true;;
let finish () =
match !all_tests_ok with
| true ->
print_endline "\nAll tests succeeded."
| _ ->
print_endline "\n\n********* Test suite failed. ***********\n";;
at_exit finish;;
let test_num = ref (-1);;
let print_test_number () =
print_string " "; print_int !test_num; flush stdout;;
let next_test () =
incr test_num;
print_test_number ();;
let print_test_fail () =
all_tests_ok := false;
print_string
(Printf.sprintf "\n********* Test number %i failed ***********\n"
!test_num);;
let print_failure_test_fail () =
all_tests_ok := false;
print_string
(Printf.sprintf
"\n********* Failure Test number %i incorrectly failed ***********\n"
!test_num);;
let print_failure_test_succeed () =
all_tests_ok := false;
print_string
(Printf.sprintf
"\n********* Failure Test number %i failed to fail ***********\n"
!test_num);;
let test b =
next_test ();
if not b then print_test_fail ();;
(* Applies f to x and checks that the evaluation indeed
raises an exception that verifies the predicate [pred]. *)
let test_raises_exc_p pred f x =
next_test ();
try
ignore (f x);
print_failure_test_succeed ();
false
with
| x ->
pred x || (print_failure_test_fail (); false);;
(* Applies f to x and checks that the evaluation indeed
raises some exception. *)
let test_raises_some_exc f = test_raises_exc_p (fun _ -> true) f;;
let test_raises_this_exc exc = test_raises_exc_p (fun x -> x = exc);;
(* Applies f to x and checks that the evaluation indeed
raises exception Failure s. *)
let test_raises_this_failure s f x =
test_raises_exc_p (fun x -> x = Failure s) f x;;
(* Applies f to x and checks that the evaluation indeed
raises the exception Failure. *)
let test_raises_some_failure f x =
test_raises_exc_p (function Failure _ -> true | _ -> false) f x;;
let failure_test f x s = test_raises_this_failure s f x;;
let any_failure_test = test_raises_some_failure;;
let scan_failure_test f x =
test_raises_exc_p (function Scan_failure _ -> true | _ -> false) f x;;
| (**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Pierre Weis, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 2006 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
|
typechecker.ml |
let consult file =
Swipl.(with_ctx @@ fun ctx -> call ctx Syntax.(app ("consult" /@ 1) [! file]))
type t =
| Lam of string * t
| Var of string
| App of t * t
type ty =
| TyVar of string
| Fun of ty * ty
let rec show_ty_ ?(needs_parens=false) =
function TyVar v -> v
| Fun (frt,tot) ->
(if needs_parens then "(" else "") ^
show_ty_ ~needs_parens:true frt ^ " -> " ^
show_ty_ tot ^
(if needs_parens then ")" else "")
let show_ty ty = show_ty_ ty
let lam var body = Swipl.Syntax.(app ("lam" /@ 2) [var; body])
let apply fn arg = Swipl.Syntax.(app ("app" /@ 2) [fn; arg])
let typeof gamma term ty = Swipl.Syntax.(app ("typeof" /@ 3) [gamma; term; ty])
let rec encode =
let open Swipl.Syntax in
function
| Lam (var, body) ->
lam (!var) (encode body)
| Var v -> !v
| App (fn,arg) -> apply (encode fn) (encode arg)
module TermMap = Map.Make(struct type t = Swipl.t let compare = Swipl.compare end)
let lookup (map,id) t =
match TermMap.find_opt t map with
| Some name -> TyVar name, (map,id)
| None ->
let name = "'" ^ String.init 1 (fun _ -> Char.chr (97 + id)) in
let map = TermMap.add t name map in
TyVar name, (map, id+1)
let decode ctx =
let (let+) x f= Option.bind x f in
let rec loop map t =
match Swipl.typeof t with
| `Variable -> Some (lookup map t)
| `Term ->
let[@warning "-8"] (_, [froty;toty]) = Swipl.extract_functor ctx t in
let+ froty, map = loop map froty in
let+ toty, map = loop map toty in
Some (Fun (froty, toty), map)
| _ -> None in
loop
let typecheck term =
Swipl.with_ctx (fun ctx ->
let result = Swipl.fresh ctx in
let query =
Swipl.eval ctx
(typeof Swipl.(encode_list ctx []) (encode term) result) in
if Swipl.first_solution query
then decode ctx (TermMap.empty, 0) result |> Option.map fst
else None
)
let () =
let () = Swipl.initialise () in
consult "./type_checker.pl";
let term = Lam("x", Lam("y", App(Var "x", App(Var "y", Var "x")))) in
match typecheck term with
| None -> print_endline @@ "Term does not type check"
| Some ty -> print_endline @@ "Term has type " ^ (show_ty ty)
| (*
SWIPL-OCaml
Copyright (C) 2021 Kiran Gopinathan
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*) |
script_typed_ir_size.ml | open Alpha_context
open Script_typed_ir
include Cache_memory_helpers
let script_string_size s = Script_string.to_string s |> string_size
(* Memo-sizes are 16-bit integers *)
let sapling_memo_size_size = !!0
let ty_traverse_f =
let base_basic =
!!0
(* Basic types count for 0 because they are all static values, hence shared
and not counted by `reachable_words`.
On the other hand compound types are functions, hence not shared. *)
in
let base_compound_no_meta = header_size in
let base_compound _meta = h1w in
let apply : type a ac. nodes_and_size -> (a, ac) ty -> nodes_and_size =
fun accu ty ->
match ty with
| Unit_t -> ret_succ_adding accu base_basic
| Int_t -> ret_succ_adding accu base_basic
| Nat_t -> ret_succ_adding accu base_basic
| Signature_t -> ret_succ_adding accu base_basic
| String_t -> ret_succ_adding accu base_basic
| Bytes_t -> ret_succ_adding accu base_basic
| Mutez_t -> ret_succ_adding accu base_basic
| Key_hash_t -> ret_succ_adding accu base_basic
| Key_t -> ret_succ_adding accu base_basic
| Timestamp_t -> ret_succ_adding accu base_basic
| Address_t -> ret_succ_adding accu base_basic
| Tx_rollup_l2_address_t -> ret_succ_adding accu base_basic
| Bool_t -> ret_succ_adding accu base_basic
| Operation_t -> ret_succ_adding accu base_basic
| Chain_id_t -> ret_succ_adding accu base_basic
| Never_t -> ret_succ_adding accu base_basic
| Bls12_381_g1_t -> ret_succ_adding accu base_basic
| Bls12_381_g2_t -> ret_succ_adding accu base_basic
| Bls12_381_fr_t -> ret_succ_adding accu base_basic
| Chest_key_t -> ret_succ_adding accu base_basic
| Chest_t -> ret_succ_adding accu base_basic
| Pair_t (_ty1, _ty2, a, _) ->
ret_succ_adding accu @@ (base_compound a +! (word_size *? 3))
| Union_t (_ty1, _ty2, a, _) ->
ret_succ_adding accu @@ (base_compound a +! (word_size *? 3))
| Lambda_t (_ty1, _ty2, a) ->
ret_succ_adding accu @@ (base_compound a +! (word_size *? 2))
| Option_t (_ty, a, _) ->
ret_succ_adding accu @@ (base_compound a +! (word_size *? 2))
| List_t (_ty, a) -> ret_succ_adding accu @@ (base_compound a +! word_size)
| Set_t (_cty, a) -> ret_succ_adding accu @@ (base_compound a +! word_size)
| Map_t (_cty, _ty, a) ->
ret_succ_adding accu @@ (base_compound a +! (word_size *? 2))
| Big_map_t (_cty, _ty, a) ->
ret_succ_adding accu @@ (base_compound a +! (word_size *? 2))
| Contract_t (_ty, a) ->
ret_succ_adding accu @@ (base_compound a +! word_size)
| Sapling_transaction_t _m ->
ret_succ_adding accu
@@ (base_compound_no_meta +! sapling_memo_size_size +! word_size)
| Sapling_transaction_deprecated_t _m ->
ret_succ_adding accu
@@ (base_compound_no_meta +! sapling_memo_size_size +! word_size)
| Sapling_state_t _m ->
ret_succ_adding accu
@@ (base_compound_no_meta +! sapling_memo_size_size +! word_size)
| Ticket_t (_cty, a) ->
ret_succ_adding accu @@ (base_compound a +! word_size)
in
({apply} : nodes_and_size ty_traverse)
let ty_size : type a ac. (a, ac) ty -> nodes_and_size =
fun ty -> ty_traverse ty zero ty_traverse_f
let stack_ty_size s =
let apply : type a s. nodes_and_size -> (a, s) stack_ty -> nodes_and_size =
fun accu s ->
match s with
| Bot_t -> ret_succ accu
| Item_t (ty, _) -> ret_succ_adding (accu ++ ty_size ty) h2w
in
stack_ty_traverse s zero {apply}
let script_nat_size n = Script_int.to_zint n |> z_size
let script_int_size n = Script_int.to_zint n |> z_size
let signature_size = !!96 (* By Obj.reachable_words. *)
let key_hash_size (_x : Signature.public_key_hash) = !!64
(* By Obj.reachable_words. *)
let public_key_size (x : public_key) =
h1w +? match x with Ed25519 _ -> 64 | Secp256k1 _ -> 72 | P256 _ -> 96
let mutez_size = h2w
let timestamp_size x = Script_timestamp.to_zint x |> z_size
let destination_size = Destination.in_memory_size
let address_size addr =
h2w
+! destination_size addr.destination
+! Entrypoint.in_memory_size addr.entrypoint
let tx_rollup_l2_address_size (tx : tx_rollup_l2_address) =
Tx_rollup_l2_address.Indexable.in_memory_size @@ Indexable.forget tx
let view_signature_size (View_signature {name; input_ty; output_ty}) =
ret_adding
(ty_size input_ty ++ ty_size output_ty)
(h3w +! script_string_size name)
let script_expr_hash_size = !!64
let peano_shape_proof =
let scale = header_size +! h1w in
fun k -> scale *? k
let stack_prefix_preservation_witness_size =
let kinfo_size = h2w in
let scale = header_size +! (h2w +! kinfo_size) in
fun k -> scale *? k
let comb_gadt_witness_size = peano_shape_proof
let uncomb_gadt_witness_size = peano_shape_proof
let comb_get_gadt_witness_size = peano_shape_proof
let comb_set_gadt_witness_size = peano_shape_proof
let dup_n_gadt_witness_size = peano_shape_proof
let contract_size (Typed_contract {arg_ty; address}) =
ret_adding (ty_size arg_ty) (h2w +! address_size address)
let sapling_state_size {Sapling.id; diff; memo_size = _} =
h3w
+! option_size (fun x -> z_size (Sapling.Id.unparse_to_z x)) id
+! Sapling.diff_in_memory_size diff
+! sapling_memo_size_size
let chain_id_size = !!16 (* by Obj.reachable_words. *)
(* [contents] is handled by the recursion scheme in [value_size]. *)
let ticket_size {ticketer; contents = _; amount} =
h3w +! Contract.in_memory_size ticketer +! script_nat_size amount
let chest_size chest =
(*
type chest = {
locked_value : locked_value;
rsa_public : rsa_public;
ciphertext : ciphertext;
}
*)
let locked_value_size = 256 in
let rsa_public_size = 256 in
let ciphertext_size = Script_timelock.get_plaintext_size chest in
h3w +? (locked_value_size + rsa_public_size + ciphertext_size)
let chest_key_size _ =
(*
type chest_key = {
unlocked_value : unlocked_value;
proof : time_lock_proof
}
*)
let unlocked_value_size = 256 in
let proof_size = 256 in
h2w +? (unlocked_value_size + proof_size)
let kinfo_size {iloc = _; kstack_ty = _} = h2w
(* The following mutually recursive functions are mostly
tail-recursive and the only recursive call that is not a tailcall
cannot be nested. (See [big_map_size].) For this reason, these
functions should not trigger stack overflows. *)
let rec value_size :
type a ac.
count_lambda_nodes:bool ->
nodes_and_size ->
(a, ac) ty ->
a ->
nodes_and_size =
fun ~count_lambda_nodes accu ty x ->
let apply : type a ac. nodes_and_size -> (a, ac) ty -> a -> nodes_and_size =
fun accu ty x ->
match ty with
| Unit_t -> ret_succ accu
| Int_t -> ret_succ_adding accu (script_int_size x)
| Nat_t -> ret_succ_adding accu (script_nat_size x)
| Signature_t -> ret_succ_adding accu signature_size
| String_t -> ret_succ_adding accu (script_string_size x)
| Bytes_t -> ret_succ_adding accu (bytes_size x)
| Mutez_t -> ret_succ_adding accu mutez_size
| Key_hash_t -> ret_succ_adding accu (key_hash_size x)
| Key_t -> ret_succ_adding accu (public_key_size x)
| Timestamp_t -> ret_succ_adding accu (timestamp_size x)
| Address_t -> ret_succ_adding accu (address_size x)
| Tx_rollup_l2_address_t ->
ret_succ_adding accu (tx_rollup_l2_address_size x)
| Bool_t -> ret_succ accu
| Pair_t (_, _, _, _) -> ret_succ_adding accu h2w
| Union_t (_, _, _, _) -> ret_succ_adding accu h1w
| Lambda_t (_, _, _) ->
(lambda_size [@ocaml.tailcall]) ~count_lambda_nodes (ret_succ accu) x
| Option_t (_, _, _) -> ret_succ_adding accu (option_size (fun _ -> !!0) x)
| List_t (_, _) -> ret_succ_adding accu (h2w +! (h2w *? x.length))
| Set_t (_, _) ->
let module M = (val Script_set.get x) in
let boxing_space = !!536 (* By Obj.reachable_words. *) in
ret_succ_adding accu (boxing_space +! (h4w *? M.size))
| Map_t (_, _, _) ->
let module M = (val Script_map.get_module x) in
let boxing_space = !!696 (* By Obj.reachable_words. *) in
ret_succ_adding accu (boxing_space +! (h5w *? M.size))
| Big_map_t (cty, ty', _) ->
(big_map_size [@ocaml.tailcall])
~count_lambda_nodes
(ret_succ accu)
cty
ty'
x
| Contract_t (_, _) -> ret_succ (accu ++ contract_size x)
| Sapling_transaction_t _ ->
ret_succ_adding accu (Sapling.transaction_in_memory_size x)
| Sapling_transaction_deprecated_t _ ->
ret_succ_adding accu (Sapling.Legacy.transaction_in_memory_size x)
| Sapling_state_t _ -> ret_succ_adding accu (sapling_state_size x)
(* Operations are neither storable nor pushable, so they can appear neither
in the storage nor in the script. Hence they cannot appear in the cache
and we never need to measure their size. *)
| Operation_t -> assert false
| Chain_id_t -> ret_succ_adding accu chain_id_size
| Never_t -> ( match x with _ -> .)
| Bls12_381_g1_t -> ret_succ_adding accu !!Bls12_381.G1.size_in_memory
| Bls12_381_g2_t -> ret_succ_adding accu !!Bls12_381.G2.size_in_memory
| Bls12_381_fr_t -> ret_succ_adding accu !!Bls12_381.Fr.size_in_memory
| Ticket_t (_, _) -> ret_succ_adding accu (ticket_size x)
| Chest_key_t -> ret_succ_adding accu (chest_key_size x)
| Chest_t -> ret_succ_adding accu (chest_size x)
in
value_traverse ty x accu {apply}
[@@coq_axiom_with_reason "unreachable expressions '.' not handled for now"]
and big_map_size :
type a b bc.
count_lambda_nodes:bool ->
nodes_and_size ->
a comparable_ty ->
(b, bc) ty ->
(a, b) big_map ->
nodes_and_size =
fun ~count_lambda_nodes accu cty ty' (Big_map {id; diff; key_type; value_type}) ->
(* [Map.bindings] cannot overflow and only consumes a
logarithmic amount of stack. *)
let diff_size =
let map_size =
Big_map_overlay.fold
(fun _key_hash (key, value) accu ->
let base = h5w +! (word_size *? 3) +! script_expr_hash_size in
let accu = ret_succ_adding accu base in
(* The following recursive call cannot introduce a stack
overflow because this would require a key of type
big_map while big_map is not comparable. *)
let accu = value_size ~count_lambda_nodes accu cty key in
match value with
| None -> accu
| Some value ->
let accu = ret_succ_adding accu h1w in
(value_size [@ocaml.tailcall]) ~count_lambda_nodes accu ty' value)
diff.map
accu
in
ret_adding map_size h2w
in
let big_map_id_size s = z_size (Big_map.Id.unparse_to_z s) in
let id_size = option_size big_map_id_size id in
ret_adding
(ty_size key_type ++ ty_size value_type ++ diff_size)
(h4w +! id_size)
and lambda_size :
type i o.
count_lambda_nodes:bool -> nodes_and_size -> (i, o) lambda -> nodes_and_size
=
fun ~count_lambda_nodes accu (Lam (kdescr, node)) ->
(* We assume that the nodes' size have already been counted if the
lambda is not a toplevel lambda. *)
let accu =
ret_adding (accu ++ if count_lambda_nodes then node_size node else zero) h2w
in
(kdescr_size [@ocaml.tailcall]) ~count_lambda_nodes:false accu kdescr
and kdescr_size :
type a s r f.
count_lambda_nodes:bool ->
nodes_and_size ->
(a, s, r, f) kdescr ->
nodes_and_size =
fun ~count_lambda_nodes accu {kloc = _; kbef; kaft; kinstr} ->
let accu =
ret_adding (accu ++ stack_ty_size kbef ++ stack_ty_size kaft) h4w
in
(kinstr_size [@ocaml.tailcall]) ~count_lambda_nodes accu kinstr
and kinstr_size :
type a s r f.
count_lambda_nodes:bool ->
nodes_and_size ->
(a, s, r, f) kinstr ->
nodes_and_size =
fun ~count_lambda_nodes accu t ->
let base kinfo = h2w +! kinfo_size kinfo in
let apply :
type a s r f. nodes_and_size -> (a, s, r, f) kinstr -> nodes_and_size =
fun accu t ->
match t with
| IDrop (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IDup (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISwap (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IConst (kinfo, x, k) ->
let accu = ret_succ_adding accu (base kinfo +! word_size) in
let (Ty_ex_c top_ty) = stack_top_ty (kinfo_of_kinstr k).kstack_ty in
(value_size [@ocaml.tailcall]) ~count_lambda_nodes accu top_ty x
| ICons_pair (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ICar (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ICdr (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IUnpair (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ICons_some (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ICons_none (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IIf_none {kinfo; _} -> ret_succ_adding accu (base kinfo)
| IOpt_map {kinfo; _} -> ret_succ_adding accu (base kinfo)
| ICons_left (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ICons_right (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IIf_left {kinfo; _} -> ret_succ_adding accu (base kinfo)
| ICons_list (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INil (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IIf_cons {kinfo; _} -> ret_succ_adding accu (base kinfo)
| IList_map (kinfo, _, _) -> ret_succ_adding accu (base kinfo)
| IList_iter (kinfo, _, _) -> ret_succ_adding accu (base kinfo)
| IList_size (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IEmpty_set (kinfo, cty, _) ->
ret_succ_adding (accu ++ ty_size cty) (base kinfo +! word_size)
| ISet_iter (kinfo, _, _) -> ret_succ_adding accu (base kinfo)
| ISet_mem (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISet_update (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISet_size (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IEmpty_map (kinfo, cty, _) ->
ret_succ_adding (accu ++ ty_size cty) (base kinfo +! word_size)
| IMap_map (kinfo, _, _) -> ret_succ_adding accu (base kinfo +! word_size)
| IMap_iter (kinfo, _, _) -> ret_succ_adding accu (base kinfo +! word_size)
| IMap_mem (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMap_get (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMap_update (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMap_get_and_update (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMap_size (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IEmpty_big_map (kinfo, cty, ty, _) ->
ret_succ_adding
(accu ++ ty_size cty ++ ty_size ty)
(base kinfo +! (word_size *? 2))
| IBig_map_mem (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IBig_map_get (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IBig_map_update (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IBig_map_get_and_update (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IConcat_string (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IConcat_string_pair (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISlice_string (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IString_size (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IConcat_bytes (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IConcat_bytes_pair (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISlice_bytes (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IBytes_size (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_seconds_to_timestamp (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_timestamp_to_seconds (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISub_timestamp_seconds (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IDiff_timestamps (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_tez (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISub_tez (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISub_tez_legacy (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_teznat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_nattez (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IEdiv_teznat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IEdiv_tez (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IOr (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAnd (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IXor (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INot (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IIs_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INeg (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAbs_int (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IInt_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_int (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISub_int (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_int (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IEdiv_int (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IEdiv_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ILsl_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ILsr_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IOr_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAnd_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAnd_int_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IXor_nat (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INot_int (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IIf {kinfo; _} -> ret_succ_adding accu (base kinfo)
| ILoop (kinfo, _, _) -> ret_succ_adding accu (base kinfo)
| ILoop_left (kinfo, _, _) -> ret_succ_adding accu (base kinfo +! word_size)
| IDip (kinfo, _, _) -> ret_succ_adding accu (base kinfo +! word_size)
| IExec (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IApply (kinfo, ty, _) ->
ret_succ_adding (accu ++ ty_size ty) (base kinfo +! word_size)
| ILambda (kinfo, lambda, _) ->
let accu = ret_succ_adding accu (base kinfo +! word_size) in
(lambda_size [@ocaml.tailcall]) ~count_lambda_nodes accu lambda
| IFailwith (kinfo, _, ty) ->
ret_succ_adding (accu ++ ty_size ty) (base kinfo +! word_size)
| ICompare (kinfo, cty, _) ->
ret_succ_adding (accu ++ ty_size cty) (base kinfo +! word_size)
| IEq (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INeq (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ILt (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IGt (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ILe (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IGe (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAddress (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IContract (kinfo, ty, s, _) ->
ret_succ_adding
(accu ++ ty_size ty)
(base kinfo +! Entrypoint.in_memory_size s +! (word_size *? 2))
| IView (kinfo, s, _) ->
ret_succ_adding (accu ++ view_signature_size s) (base kinfo +! word_size)
| ITransfer_tokens (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IImplicit_account (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ICreate_contract {kinfo; storage_type; code; k = _} ->
ret_succ_adding
(accu ++ ty_size storage_type ++ expr_size code)
(base kinfo +! (word_size *? 2))
| ISet_delegate (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INow (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMin_block_time (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IBalance (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ILevel (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ICheck_signature (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IHash_key (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IPack (kinfo, ty, _) ->
ret_succ_adding (accu ++ ty_size ty) (base kinfo +! word_size)
| IUnpack (kinfo, ty, _) ->
ret_succ_adding (accu ++ ty_size ty) (base kinfo +! word_size)
| IBlake2b (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISha256 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISha512 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISource (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISender (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISelf (kinfo, ty, s, _) ->
ret_succ_adding
(accu ++ ty_size ty)
(base kinfo +! (word_size *? 2) +! Entrypoint.in_memory_size s)
| ISelf_address (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAmount (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISapling_empty_state (kinfo, _m, _) ->
ret_succ_adding accu (base kinfo +! word_size +! sapling_memo_size_size)
| ISapling_verify_update (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISapling_verify_update_deprecated (kinfo, _) ->
ret_succ_adding accu (base kinfo)
| IDig (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2)
+! stack_prefix_preservation_witness_size n)
| IDug (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2)
+! stack_prefix_preservation_witness_size n)
| IDipn (kinfo, n, _, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2)
+! stack_prefix_preservation_witness_size n)
| IDropn (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2)
+! stack_prefix_preservation_witness_size n)
| IChainId (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INever kinfo -> ret_succ_adding accu (kinfo_size kinfo)
| IVoting_power (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ITotal_voting_power (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IKeccak (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISha3 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_bls12_381_g1 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_bls12_381_g2 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IAdd_bls12_381_fr (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_bls12_381_g1 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_bls12_381_g2 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_bls12_381_fr (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_bls12_381_z_fr (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IMul_bls12_381_fr_z (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IInt_bls12_381_fr (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INeg_bls12_381_g1 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INeg_bls12_381_g2 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| INeg_bls12_381_fr (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IPairing_check_bls12_381 (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IComb (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2) +! comb_gadt_witness_size n)
| IUncomb (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2) +! uncomb_gadt_witness_size n)
| IComb_get (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2) +! comb_get_gadt_witness_size n)
| IComb_set (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2) +! comb_set_gadt_witness_size n)
| IDup_n (kinfo, n, _, _) ->
ret_succ_adding
accu
(base kinfo +! (word_size *? 2) +! dup_n_gadt_witness_size n)
| ITicket (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IRead_ticket (kinfo, _) -> ret_succ_adding accu (base kinfo)
| ISplit_ticket (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IJoin_tickets (kinfo, cty, _) ->
ret_succ_adding (accu ++ ty_size cty) (base kinfo +! word_size)
| IOpen_chest (kinfo, _) -> ret_succ_adding accu (base kinfo)
| IHalt kinfo -> ret_succ_adding accu (h1w +! kinfo_size kinfo)
| ILog (_, _, _, _) ->
(* This instruction is ignored because it is only used for testing. *)
accu
in
kinstr_traverse t accu {apply}
let rec kinstr_extra_size : type a s r f. (a, s, r, f) kinstr -> nodes_and_size
=
fun t ->
let ret_zero x = (Nodes.zero, x) in
let apply :
type a s r f. nodes_and_size -> (a, s, r, f) kinstr -> nodes_and_size =
fun accu t ->
let stack_prefix_preservation_witness_size n = ret_zero (!!24 *? n) in
let dup_n_gadt_witness_size n = ret_zero (!!16 *? n) in
let comb n = ret_zero (!!16 *? n) in
let self_size =
match t with
(* Op n *)
| IDig (_, n, _, _) -> stack_prefix_preservation_witness_size n
| IDug (_, n, _, _) -> stack_prefix_preservation_witness_size n
| IDipn (_, n, _, _, _) -> stack_prefix_preservation_witness_size n
| IDropn (_, n, _, _) -> stack_prefix_preservation_witness_size n
| IComb (_, n, _, _) -> comb n
| IUncomb (_, n, _, _) -> comb n
| IComb_get (_, n, _, _) -> comb (n / 2)
| IComb_set (_, n, _, _) -> comb (n / 2)
| IDup_n (_, n, _, _) -> dup_n_gadt_witness_size n
(* Other extra *)
| ILambda (_, lambda, _) -> lambda_extra_size lambda
| _ -> zero
in
ret_succ (accu ++ self_size)
in
kinstr_traverse t zero {apply}
and lambda_extra_size : type i o. (i, o) lambda -> nodes_and_size =
fun (Lam ({kinstr; _}, _)) -> kinstr_extra_size kinstr
let lambda_size lam =
(*
The following formula has been obtained through a regression
over the corpus of mainnet contracts in Granada.
*)
let (lambda_nodes, lambda_size) =
lambda_size ~count_lambda_nodes:true zero lam
in
let (lambda_extra_size_nodes, lambda_extra_size) = lambda_extra_size lam in
let size = (lambda_size *? 157 /? 100) +! (lambda_extra_size *? 18 /? 100) in
(Nodes.add lambda_nodes lambda_extra_size_nodes, size)
let kinstr_size kinstr =
let (kinstr_extra_size_nodes, kinstr_extra_size) = kinstr_extra_size kinstr in
let (kinstr_nodes, kinstr_size) =
kinstr_size ~count_lambda_nodes:true zero kinstr
in
let size = (kinstr_size *? 157 /? 100) +! (kinstr_extra_size *? 18 /? 100) in
(Nodes.add kinstr_nodes kinstr_extra_size_nodes, size)
let value_size ty x = value_size ~count_lambda_nodes:true zero ty x
module Internal_for_tests = struct
let ty_size = ty_size
let kinstr_size = kinstr_size
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2021-2022 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
listDomains.mli |
open Types
type input = ListDomainsRequest.t
type output = ListDomainsResult.t
type error = Errors_internal.t
include
Aws.Call with type input := input and type output := output and type
error := error |