Import brltty

grub-core/braille/brltty/Bindings/OCaml/META

@@ -0,0 +1,5 @@
+requires = "unix"
+description = "Bindings for the libbrlapi braille enabling library"
+archive(byte) = "brlapi.cma"
+archive(native) = "brlapi.cmxa"
+version = "0.1"

grub-core/braille/brltty/Bindings/OCaml/bindings.m4

@@ -0,0 +1,156 @@
+# autoconf input for Objective Caml programs
+# Copyright (C) 2001 Jean-Christophe Filliâtre
+#   from a first script by Georges Mariano 
+# 
+# Modified to be an autoconf m4 function in 2006
+# for BRLTTY [http://mielke.cc/brltty/]
+# by Dave Mielke <dave@mielke.cc>
+# 
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License version 2, as published by the Free Software Foundation.
+# 
+# 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 GNU Library General Public License version 2 for more details
+# (enclosed in the file LGPL).
+
+# the script generated by autoconf from this input will set the following
+# variables:
+#   OCAMLC        "ocamlc" if present in the path, or a failure
+#                 or "ocamlc.opt" if present with same version number as ocamlc
+#   OCAMLOPT      "ocamlopt" (or "ocamlopt.opt" if present), or "no"
+#   OCAMLMKLIB      "ocamlkmlib", or "no"
+#   OCAMLBEST     either "byte" if no native compiler was found, 
+#                 or "opt" otherwise
+#   OCAMLDEP      "ocamldep"
+#   OCAMLLEX      "ocamllex" (or "ocamllex.opt" if present)
+#   OCAMLYACC     "ocamlyac"
+#   OCAMLLIB      the path to the ocaml standard library
+#   OCAMLVERSION  the ocaml version number
+#   OCAMLWEB      "ocamlweb" (not mandatory)
+#   OCAMLWIN32    "yes"/"no" depending on Sys.os_type = "Win32"
+
+AC_DEFUN([BRLTTY_OCAML_BINDINGS], [dnl
+# Check for Ocaml compilers
+
+# we first look for ocamlc in the path; if not present, we fail
+AC_CHECK_PROG(OCAMLC,ocamlc,ocamlc,no)
+if test "$OCAMLC" = no ; then
+    AC_MSG_WARN([Cannot find ocamlc.])
+    OCAML_OK=false
+else
+    # checking for ocamlmklib
+    AC_CHECK_PROG(OCAMLMKLIB,ocamlmklib,ocamlmklib,no)
+    if test "$OCAMLMKLIB" = no ; then
+        AC_MSG_WARN([Cannot find ocamlmklib.])
+        OCAML_OK=false
+    else    
+        OCAML_OK=true
+        # we extract Ocaml version number and library path
+        OCAMLVERSION=`$OCAMLC -version`
+        AC_MSG_NOTICE([OCaml version is $OCAMLVERSION])
+
+        OCAMLLIB=`$OCAMLC -where`
+        AC_MSG_NOTICE([OCaml library path is $OCAMLLIB])
+
+        # then we look for ocamlopt; if not present, we issue a warning
+        # if the version is not the same, we also discard it
+        # we set OCAMLBEST to "opt" or "byte", whether ocamlopt is available or not
+        AC_CHECK_PROG(OCAMLOPT,ocamlopt,ocamlopt,no)
+        OCAMLBEST=byte
+        OCAML_NCLIB=
+        if test "$OCAMLOPT" = no ; then
+            AC_MSG_WARN([Cannot find ocamlopt; bytecode compilation only.])
+        else
+            AC_MSG_CHECKING(ocamlopt version)
+            TMPVERSION=`$OCAMLOPT -v | sed -n -e 's|.*version *\(.*\)$|\1|p' `
+            if test "$TMPVERSION" != "$OCAMLVERSION" ; then
+                AC_MSG_RESULT(differs from ocamlc; ocamlopt discarded.)
+                OCAMLOPT=no
+            else
+                AC_MSG_RESULT(ok)
+                OCAMLBEST=opt
+                OCAML_NCLIB="\$(OCAML_LIB).cmxa"
+            fi
+        fi
+
+        # checking for ocamlc.opt
+        AC_CHECK_PROG(OCAMLCDOTOPT,ocamlc.opt,ocamlc.opt,no)
+        if test "$OCAMLCDOTOPT" != no ; then
+            AC_MSG_CHECKING(ocamlc.opt version)
+            TMPVERSION=`$OCAMLCDOTOPT -v | sed -n -e 's|.*version *\(.*\)$|\1|p' `
+            if test "$TMPVERSION" != "$OCAMLVERSION" ; then
+                AC_MSG_RESULT(differs from ocamlc; ocamlc.opt discarded.)
+            else
+                AC_MSG_RESULT(ok)
+                OCAMLC=$OCAMLCDOTOPT
+            fi
+        fi
+
+        # checking for ocamlopt.opt
+        if test "$OCAMLOPT" != no ; then
+            AC_CHECK_PROG(OCAMLOPTDOTOPT,ocamlopt.opt,ocamlopt.opt,no)
+            if test "$OCAMLOPTDOTOPT" != no ; then
+                AC_MSG_CHECKING(ocamlc.opt version)
+                TMPVER=`$OCAMLOPTDOTOPT -v | sed -n -e 's|.*version *\(.*\)$|\1|p' `
+                if test "$TMPVER" != "$OCAMLVERSION" ; then
+                    AC_MSG_RESULT(differs from ocamlc; ocamlopt.opt discarded.)
+                else
+                    AC_MSG_RESULT(ok)
+                    OCAMLOPT=$OCAMLOPTDOTOPT
+                fi
+            fi
+        fi
+
+        # platform
+        AC_MSG_CHECKING(platform)
+        if echo "let _ = Sys.os_type;;" | ocaml | grep -q Win32; then
+            AC_MSG_RESULT(Win32)
+            OCAMLWIN32=yes
+            OCAML_CLIBS=libbrlapi_stubs.a
+        elif echo "let _ = Sys.os_type;;" | ocaml | grep -q Cygwin; then
+            AC_MSG_RESULT(Cygwin)
+            OCAMLWIN32=yes
+            OCAML_CLIBS=libbrlapi_stubs.a
+        else
+            AC_MSG_RESULT(Unix)
+            OCAMLWIN32=no
+            OCAML_CLIBS="libbrlapi_stubs.a dllbrlapi_stubs.so"
+        fi
+    
+        # checking for ocamlfindlib
+        AC_CHECK_PROG(OCAMLFIND,ocamlfind,ocamlfind,no)
+        if test "$OCAMLFIND" = ocamlfind; then
+            OCAMLC='ocamlfind ocamlc'
+            if test "$OCAMLOPT" = ocamlopt; then
+                OCAMLOPT='ocamlfind ocamlopt'
+            fi
+            OCAML_INSTALL_TARGET=install-with-findlib
+            OCAML_UNINSTALL_TARGET=uninstall-without-findlib
+        else
+            OCAML_INSTALL_TARGET=install-without-findlib
+            OCAML_UNINSTALL_TARGET=uninstall-without-findlib
+            AC_MSG_WARN([Cannot find ocamlfind.])
+        fi
+    fi
+fi
+
+# substitutions to perform
+AC_SUBST(OCAMLC)
+AC_SUBST(OCAMLOPT)
+AC_SUBST(OCAMLMKLIB)
+AC_SUBST(OCAMLBEST)
+AC_SUBST(OCAMLVERSION)
+AC_SUBST(OCAMLLIB)
+AC_SUBST(OCAMLWIN32)
+AC_SUBST(OCAML_CLIBS)
+AC_SUBST(OCAML_NCLIB)
+AC_SUBST(OCAMLFIND)
+AC_SUBST(OCAML_INSTALL_TARGET)
+AC_SUBST(OCAML_UNINSTALL_TARGET)
+
+AC_SUBST([OCAML_OK])
+])

grub-core/braille/brltty/Bindings/OCaml/brlapi_stubs.c

@@ -0,0 +1,482 @@
+/*
+ * libbrlapi - A library providing access to braille terminals for applications.
+ *
+ * Copyright (C) 2005-2012 by
+ *   Sébastien Hinderer <Sebastien.Hinderer@ens-lyon.org>
+ *   Samuel Thibault <Samuel.Thibault@ens-lyon.org>
+ * All rights reserved.
+ *
+ * libbrlapi comes with ABSOLUTELY NO WARRANTY.
+ *
+ * This is free software, placed 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. Please see the file LICENSE-LGPL for details.
+ *
+ * Web Page: http://mielke.cc/brltty/
+ *
+ * This software is maintained by Dave Mielke <dave@mielke.cc>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#define CAML_NAME_SPACE /* Don't import old names */
+#include <caml/mlvalues.h> /* definition of the value type, and conversion macros */
+#include <caml/memory.h> /* miscellaneous memory-related functions and macros (for GC interface, in-place modification of structures, etc). */
+#include <caml/alloc.h> /* allocation functions (to create structured Caml objects) */
+#include <caml/fail.h> /* functions for raising exceptions */
+#include <caml/callback.h> /* callback from C to Caml */
+#include <caml/custom.h> /* operations on custom blocks */
+#include <caml/intext.h> /* operations for writing user-defined serialization and deserialization functions for custom blocks */
+#define BRLAPI_NO_DEPRECATED
+#include "brlapi.h"
+#include "brlapi_protocol.h"
+
+#ifndef MIN
+#define MIN(x, y) (x<y)?(x):(y)
+#endif /* MIN */
+
+extern value unix_error_of_code (int errcode); /* TO BE REMOVED */
+
+/* The following macros call a BrlAPI function */
+/* The first one just calls the function, whereas */
+/* the second one also checks the function's return code and raises */
+/* an exception if this code is -1 */
+/* The macros decide which version of a brlapi function should be called */
+/* depending on whether the handle value is None or Some realHandle */
+
+#define brlapi(function, ...) \
+do { \
+  if (Is_long(handle)) brlapi_ ## function (__VA_ARGS__); \
+  else brlapi__ ## function ((brlapi_handle_t *) Data_custom_val(Field(handle, 0)), ## __VA_ARGS__); \
+} while (0)
+
+#define brlapiCheckError(function, ...) \
+do { \
+  int res_; \
+  if (Is_long(handle)) res_ = brlapi_ ##function (__VA_ARGS__); \
+  else res_ = brlapi__ ##function ((brlapi_handle_t *) Data_custom_val(Field(handle, 0)), ## __VA_ARGS__); \
+  if (res_==-1) raise_brlapi_error(); \
+} while (0)
+
+#define brlapiCheckErrorWithCode(function, ret, ...) \
+do { \
+  int res_; \
+  if (Is_long(handle)) res_ = brlapi_ ##function (__VA_ARGS__); \
+  else res_ = brlapi__ ##function ((brlapi_handle_t *) Data_custom_val(Field(handle, 0)), ## __VA_ARGS__); \
+  if (res_==-1) raise_brlapi_error(); \
+  (*(int *)ret) = res_; \
+} while (0)
+
+static int compareHandle(value h1, value h2)
+{
+  CAMLparam2(h1, h2);
+  CAMLreturn(memcmp(Data_custom_val(h1), Data_custom_val(h2), brlapi_getHandleSize()));
+}
+
+static struct custom_operations customOperations = {
+  .identifier = "BrlAPI handle",
+  .finalize = custom_finalize_default,
+  .compare = compareHandle,
+  .hash = custom_hash_default, /* FIXME: provide a genuine hashing function */
+  .serialize = custom_serialize_default,
+  .deserialize = custom_deserialize_default,
+};
+
+/* Function : constrCamlError */
+/* Converts a brlapi_error_t into its Caml representation */
+static value constrCamlError(const brlapi_error_t *err)
+{
+  value camlError;
+  camlError = caml_alloc_tuple(4);
+  Store_field(camlError, 0, Val_int(err->brlerrno));
+  Store_field(camlError, 1, Val_int(err->libcerrno));
+  Store_field(camlError, 2, Val_int(err->gaierrno));
+  if (err->errfun!=NULL)
+    Store_field(camlError, 3, caml_copy_string(err->errfun));
+  else
+    Store_field(camlError, 3, caml_copy_string(""));
+  return camlError;
+}
+
+CAMLprim value brlapiml_errorCode_of_error(value camlError)
+{
+  CAMLparam1(camlError);
+  CAMLlocal1(result);
+  switch (Int_val(Field(camlError, 0))) {
+    case BRLAPI_ERROR_NOMEM: result = Val_int(0); break;
+    case BRLAPI_ERROR_TTYBUSY: result = Val_int(1); break;
+    case BRLAPI_ERROR_DEVICEBUSY: result = Val_int(2); break;
+    case BRLAPI_ERROR_UNKNOWN_INSTRUCTION: result = Val_int(3); break;
+    case BRLAPI_ERROR_ILLEGAL_INSTRUCTION: result = Val_int(4); break;
+    case BRLAPI_ERROR_INVALID_PARAMETER: result = Val_int(5); break;
+    case BRLAPI_ERROR_INVALID_PACKET: result = Val_int(6); break;
+    case BRLAPI_ERROR_CONNREFUSED: result = Val_int(7); break;
+    case BRLAPI_ERROR_OPNOTSUPP: result = Val_int(8); break;
+    case BRLAPI_ERROR_GAIERR: {
+      result = caml_alloc(1, 0);
+      Store_field(result, 0, Val_int(Field(camlError, 2)));
+    }; break;
+    case BRLAPI_ERROR_LIBCERR: {
+      result = caml_alloc(1, 1);
+      Store_field(result, 0, unix_error_of_code(Int_val(Field(camlError, 1))));
+    }; break;
+    case BRLAPI_ERROR_UNKNOWNTTY: result = Val_int(9); break;
+    case BRLAPI_ERROR_PROTOCOL_VERSION: result = Val_int(10); break;
+    case BRLAPI_ERROR_EOF: result = Val_int(11); break;
+    case BRLAPI_ERROR_EMPTYKEY: result = Val_int(12); break; 
+    case BRLAPI_ERROR_DRIVERERROR: result = Val_int(13); break;
+    case BRLAPI_ERROR_AUTHENTICATION: result = Val_int(14); break;
+    default: {
+      result = caml_alloc(1, 2);
+      Store_field(result, 0, Val_int(Field(camlError, 0)));
+    }
+  }
+  CAMLreturn(result);
+}
+
+/* Function : raise_brlapi_error */
+/* Raises the Brlapi_error exception */
+static void raise_brlapi_error(void)
+{
+  static value *exception = NULL;
+  CAMLlocal1(res);
+  if (exception==NULL) exception = caml_named_value("Brlapi_error");
+  res = caml_alloc(2,0);
+  Store_field(res, 0, *exception);
+  Store_field(res, 1, constrCamlError(&brlapi_error));
+  caml_raise(res);
+}
+
+/* Function : raise_brlapi_exception */
+/* Raises Brlapi_exception */
+static void BRLAPI_STDCALL raise_brlapi_exception(int err, brlapi_packetType_t type, const void *packet, size_t size)
+{
+  static value *exception = NULL;
+  int i;
+  CAMLlocal2(str, res);
+  str = caml_alloc_string(size);
+  for (i=0; i<size; i++) Byte(str, i) = ((char *) packet)[i];
+  if (exception==NULL) exception = caml_named_value("Brlapi_exception");
+  res = caml_alloc (4, 0);
+  Store_field(res, 0, *exception);
+  Store_field(res, 1, Val_int(err));
+  Store_field(res, 2, caml_copy_int32(type));
+  Store_field(res, 3, str);
+  caml_raise(res);
+}
+
+/* function packDots */
+/* Converts Caml dots in brltty dots */
+static inline void packDots(value camlDots, unsigned char *dots, int size)
+{
+  unsigned int i;
+  for (i=0; i<size; i++)
+    dots[i] = Int_val(Field(camlDots, i));
+}
+
+CAMLprim value brlapiml_openConnection(value settings)
+{
+  CAMLparam1(settings);
+  CAMLlocal2(s, pair);
+  int res;
+  brlapi_connectionSettings_t brlapiSettings;
+  brlapiSettings.auth = String_val(Field(settings, 0));
+  brlapiSettings.host = String_val(Field(settings, 1));
+  res = brlapi_openConnection(&brlapiSettings, &brlapiSettings);
+  if (res<0) raise_brlapi_error();
+  s = caml_alloc_tuple(2);
+  Store_field(s, 0, caml_copy_string(brlapiSettings.auth));
+  Store_field(s, 1, caml_copy_string(brlapiSettings.host));
+  pair = caml_alloc_tuple(2);
+  Store_field(pair, 0, Val_int(res));
+  Store_field(pair, 1, s);
+  CAMLreturn(pair);
+}
+
+CAMLprim value brlapiml_openConnectionWithHandle(value settings)
+{
+  CAMLparam1(settings);
+  CAMLlocal1(handle);
+  brlapi_connectionSettings_t brlapiSettings;
+  brlapiSettings.auth = String_val(Field(settings, 0));
+  brlapiSettings.host = String_val(Field(settings, 1));
+  handle = caml_alloc_custom(&customOperations, brlapi_getHandleSize(), 0, 1);
+  if (brlapi__openConnection(Data_custom_val(handle), &brlapiSettings, &brlapiSettings)<0) raise_brlapi_error();
+  CAMLreturn(handle);
+}
+
+CAMLprim value brlapiml_closeConnection(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  brlapi(closeConnection);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_getDriverName(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  char name[BRLAPI_MAXNAMELENGTH];
+  brlapiCheckError(getDriverName, name, sizeof(name));
+  CAMLreturn(caml_copy_string(name));
+}
+
+CAMLprim value brlapiml_getDisplaySize(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  CAMLlocal1(size);
+  unsigned int x, y;
+  brlapiCheckError(getDisplaySize, &x, &y);
+  size = caml_alloc_tuple(2);
+  Store_field(size, 0, Val_int(x));
+  Store_field(size, 1, Val_int(y));
+  CAMLreturn(size);
+}
+
+CAMLprim value brlapiml_enterTtyMode(value handle, value tty, value driverName)
+{
+  CAMLparam3(handle, tty, driverName);
+  int res;
+  brlapiCheckErrorWithCode(enterTtyMode, &res, Int_val(tty), String_val(driverName));
+  CAMLreturn(Val_int(res));
+}
+
+CAMLprim value brlapiml_enterTtyModeWithPath(value handle, value ttyPathCaml, value driverName)
+{
+  CAMLparam3(handle, ttyPathCaml, driverName);
+  int i, size = Wosize_val(ttyPathCaml);
+  int ttyPath[size];
+  for (i=0; i<size; i++) ttyPath[i] = Int_val(Field(ttyPathCaml, i));
+  brlapiCheckError(enterTtyModeWithPath, ttyPath, size, String_val(driverName));
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_leaveTtyMode(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  brlapi(leaveTtyMode);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_setFocus(value handle, value tty)
+{
+  CAMLparam2(handle, tty);
+  brlapiCheckError(setFocus, Int_val(tty));
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_writeText(value handle, value cursor, value text)
+{
+  CAMLparam3(handle, cursor, text);
+  brlapiCheckError(writeText, Int_val(cursor), String_val(text));
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_writeDots(value handle, value camlDots)
+{
+  CAMLparam2(handle, camlDots);
+  int size = Wosize_val(camlDots);
+  unsigned char dots[size];
+  packDots(camlDots, dots, size);
+  brlapiCheckError(writeDots, dots);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_write(value handle, value writeArguments)
+{
+  CAMLparam2(handle, writeArguments);
+  int andSize = Wosize_val(Field(writeArguments, 4));
+  int orSize = Wosize_val(Field(writeArguments, 5));
+  unsigned char andMask[andSize], orMask[orSize];
+  brlapi_writeArguments_t wa;
+  wa.displayNumber = Val_int(Field(writeArguments, 0));
+  wa.regionBegin = Val_int(Field(writeArguments, 1));
+  wa.regionSize = Val_int(Field(writeArguments, 2));
+  wa.text = String_val(Field(writeArguments, 3));
+  packDots(Field(writeArguments, 4), andMask, andSize);
+  wa.andMask = andMask;
+  packDots(Field(writeArguments, 5), orMask, orSize);
+  wa.orMask = orMask;
+  wa.cursor = Val_int(Field(writeArguments, 6));
+  wa.charset = String_val(Field(writeArguments, 7));
+  brlapiCheckError(write, &wa);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_readKey(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  int res;
+  brlapi_keyCode_t keyCode;
+  CAMLlocal1(retVal);
+  brlapiCheckErrorWithCode(readKey, &res, 0, &keyCode);
+  if (res==0) CAMLreturn(Val_int(0));
+  retVal = caml_alloc(1, 1);
+  Store_field(retVal, 0, caml_copy_int64(keyCode));
+  CAMLreturn(retVal);
+}
+
+CAMLprim value brlapiml_waitKey(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  brlapi_keyCode_t keyCode;
+  brlapiCheckError(readKey, 1, &keyCode);
+  CAMLreturn(caml_copy_int64(keyCode));
+}
+
+#define brlapi__expandKeyCode(h,x,y) brlapi_expandKeyCode(x,y)
+
+CAMLprim value brlapiml_expandKeyCode(value handle, value camlKeyCode)
+{
+  CAMLparam2(handle, camlKeyCode);
+  CAMLlocal1(result);
+  brlapi_expandedKeyCode_t ekc;
+  brlapiCheckError(expandKeyCode, Int64_val(camlKeyCode), &ekc);
+  result = caml_alloc_tuple(4);
+  Store_field(result, 0, caml_copy_int32(ekc.type));
+  Store_field(result, 1, caml_copy_int32(ekc.command));
+  Store_field(result, 2, caml_copy_int32(ekc.argument));
+  Store_field(result, 2, caml_copy_int32(ekc.flags));
+  CAMLreturn(result);
+}
+
+CAMLprim value brlapiml_ignoreKeys(value handle, value rt, value camlKeys)
+{
+  CAMLparam3(handle, rt, camlKeys);
+  unsigned int i, size = Wosize_val(camlKeys);
+  brlapi_keyCode_t keys[size];
+  for (i=0; i<size; i++) keys[i] = Int64_val(Field(camlKeys, i)); 
+  brlapiCheckError(ignoreKeys, Int_val(rt), keys, size);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_acceptKeys(value handle, value rt, value camlKeys)
+{
+  CAMLparam3(handle, rt, camlKeys);
+  unsigned int i, size = Wosize_val(camlKeys);
+  brlapi_keyCode_t keys[size];
+  for (i=0; i<size; i++) keys[i] = Int64_val(Field(camlKeys, i)); 
+  brlapiCheckError(acceptKeys, Int_val(rt), keys, size);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_ignoreAllKeys(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  brlapiCheckError(ignoreAllKeys);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_acceptAllKeys(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  brlapiCheckError(acceptAllKeys);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_ignoreKeyRanges(value handle, value camlRanges)
+{
+  CAMLparam2(handle, camlRanges);
+  CAMLlocal1(r);
+  unsigned int i, size = Wosize_val(camlRanges);
+  brlapi_range_t ranges[size];
+  for (i=0; i<size; i++) {
+    r = Field(camlRanges, i);
+    ranges[i].first = Int64_val(Field(r, 0));
+    ranges[i].last = Int64_val(Field(r, 1));
+  }
+  brlapiCheckError(ignoreKeyRanges, ranges, size);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_acceptKeyRanges(value handle, value camlRanges)
+{
+  CAMLparam2(handle, camlRanges);
+  CAMLlocal1(r);
+  unsigned int i, size = Wosize_val(camlRanges);
+  brlapi_range_t ranges[size];
+  for (i=0; i<size; i++) {
+    r = Field(camlRanges, i);
+    ranges[i].first = Int64_val(Field(r, 0));
+    ranges[i].last = Int64_val(Field(r, 1));
+  }
+  brlapiCheckError(acceptKeyRanges, ranges, size);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_enterRawMode(value handle, value driverName)
+{
+  CAMLparam2(handle, driverName);
+  brlapiCheckError(enterRawMode, String_val(driverName));
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_leaveRawMode(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  brlapi(leaveRawMode);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_sendRaw(value handle, value str)
+{
+  CAMLparam2(handle, str);
+  int res;
+  unsigned char packet[BRLAPI_MAXPACKETSIZE];
+  ssize_t i, size = MIN(sizeof(packet), caml_string_length(str));
+  for (i=0; i<size; i++) packet[i] = Byte(str, i);
+  brlapiCheckErrorWithCode(sendRaw, &res, packet, size);
+  CAMLreturn(Val_int(res));
+}
+
+CAMLprim value brlapiml_recvRaw(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  unsigned char packet[BRLAPI_MAXPACKETSIZE];
+  int i, size;
+  CAMLlocal1(str);
+  brlapiCheckErrorWithCode(recvRaw, &size, packet, sizeof(packet));
+  str = caml_alloc_string(size);
+  for (i=0; i<size; i++) Byte(str, i) = packet[i];
+  CAMLreturn(str);
+}
+
+CAMLprim value brlapiml_suspendDriver(value handle, value driverName)
+{
+  CAMLparam2(handle, driverName);
+  brlapiCheckError(suspendDriver, String_val(driverName));
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_resumeDriver(value handle, value unit)
+{
+  CAMLparam2(handle, unit);
+  brlapi(resumeDriver);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value brlapiml_strerror(value camlError)
+{
+  CAMLparam1(camlError);
+  brlapi_error_t error;
+  error.brlerrno = Int_val(Field(camlError,0));
+  error.libcerrno = Int_val(Field(camlError,1));
+  error.gaierrno = Int_val(Field(camlError,2));
+  error.errfun = String_val(Field(camlError,3));
+  CAMLreturn(caml_copy_string(brlapi_strerror(&error)));
+}
+
+/* Function : setExceptionHandler */
+/* Sets a handler that raises a Caml exception each time a brlapi */
+/* exception occurs */
+CAMLprim value brlapiml_setExceptionHandler(value unit)
+{
+  CAMLparam1(unit);
+  brlapi_setExceptionHandler(raise_brlapi_exception);
+  CAMLreturn(Val_unit);
+}

grub-core/braille/brltty/Bindings/OCaml/constants.awk

@@ -0,0 +1,117 @@
+###############################################################################
+# BRLTTY - A background process providing access to the console screen (when in
+#          text mode) for a blind person using a refreshable braille display.
+#
+# Copyright (C) 1995-2012 by The BRLTTY Developers.
+#
+# BRLTTY comes with ABSOLUTELY NO WARRANTY.
+#
+# This is free software, placed 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. Please see the file LICENSE-GPL for details.
+#
+# Web Page: http://mielke.cc/brltty/
+#
+# This software is maintained by Dave Mielke <dave@mielke.cc>.
+###############################################################################
+
+BEGIN {
+}
+
+END {
+}
+
+function brlCommand(name, symbol, value, help) {
+  writeCommandDefinition("cmd_" name, "Int32.of_int " value, help)
+}
+
+function brlBlock(name, symbol, value, help) {
+  if (value ~ /^0[xX][0-9a-fA-F]+00$/) {
+    writeCommandDefinition("blk_" name, "Int32.of_int " hexadecimalValue(value) "00", help)
+  }
+}
+
+function brlKey(name, symbol, value, help) {
+# not implemented for other bindings either
+#  print "braille key:"
+#  print name symbol value
+#  print "(** " help " *)"
+}
+
+function brlFlag(name, symbol, value, help) {
+  if (value ~ /^0[xX][0-9a-fA-F]+0000$/) {
+    value = hexadecimalValue(substr(value, 1, length(value)-4))
+    if (name ~ /^CHAR_/) {
+      name = substr(name, 6)
+    } else {
+      value = value "00"
+    }
+  } else if (value ~ /^\(/) {
+    return
+  } else {
+    return
+  }
+  writeCamlConstant("int32", "KEY_FLG_" name, "Int32.of_int " tolower(value), help)
+}
+
+function brlDot(number, symbol, value, help) {
+  writeCamlConstant("int", "dot" number, value, help)
+}
+
+function apiConstant(name, symbol, value, help) {
+  writeCamlConstant("int", name, value);
+}
+
+function apiMask(name, symbol, value, help) {
+  writeCamlConstant("int64", "key_" tolower(name), hexadecimalValue(value) "L");
+}
+
+function apiShift(name, symbol, value, help) {
+  writeCamlConstant("int", "key_" tolower(name), hexadecimalValue(value));
+}
+
+function apiType(name, symbol, value, help) {
+  writeCamlConstant("int", "key_type_" tolower(name), hexadecimalValue(value));
+}
+
+function apiKey(name, symbol, value, help) {
+  value = hexadecimalValue(value)
+
+  if (name == "FUNCTION") {
+    for (i=0; i<35; ++i) {
+      writeKeyDefinition("F" (i+1), "(" value " + " i ")")
+    }
+  } else {
+    writeKeyDefinition(name, value)
+  }
+}
+
+function apiRangeType(name, symbol, value, help) {
+  writeCamlConstant("int", "rangeType_" name, value, help)
+}
+
+function writeCommandDefinition(name, value, help) {
+  writeCamlConstant("int32", name, value, help)
+}
+
+function writeKeyDefinition(name, value) {
+  writeCamlConstant("int32", "KEY_SYM_" name, "Int32.of_int " value)
+}
+
+function writeCamlConstant(type, name, value, help) {
+  print "let " tolower(name) " : " type " = " value " " camldocComment(help)
+}
+
+function camldocComment(text) {
+  if (length(text) > 0) value = "(** " text " *)";
+  else value = "";
+  return value;
+}
+
+function hexadecimalValue(value) {
+  value = tolower(value)
+  gsub("x0+", "x", value)
+  gsub("x$", "x0", value)
+  return value
+}

grub-core/braille/brltty/Bindings/OCaml/main.ml

@@ -0,0 +1,213 @@
+(*
+ * libbrlapi - A library providing access to braille terminals for applications.
+ *
+ * Copyright (C) 2002-2012 by
+ *   Sébastien Hinderer <Sebastien.Hinderer@ens-lyon.org>
+ *   Samuel Thibault <Samuel.Thibault@ens-lyon.org>
+ * All rights reserved.
+ *
+ * libbrlapi comes with ABSOLUTELY NO WARRANTY.
+ *
+ * This is free software, placed 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. Please see the file LICENSE-LGPL for details.
+ *
+ * Web Page: http://mielke.cc/brltty/
+ *
+ * This software is maintained by Dave Mielke <dave@mielke.cc>.
+ *)
+
+(* BrlAPI Interface for the OCaml language *)
+
+let dot1 = 1 lsl 0
+let dot2 = 1 lsl 1
+let dot3 = 1 lsl 2
+let dot4 = 1 lsl 3
+let dot5 = 1 lsl 4
+let dot6 = 1 lsl 5
+let dot7 = 1 lsl 6
+let dot8 = 1 lsl 7
+
+type settings = {
+  auth : string;
+  host : string
+}
+
+let settings_initializer = {
+  auth = "";
+  host = ""
+}
+
+type writeArguments = {
+  mutable displayNumber : int;
+  mutable regionBegin : int;
+  mutable regionSize : int;
+  text : string;
+  attrAnd : int array;
+  attrOr : int array;
+  mutable cursor : int;
+  mutable charset : string
+}
+
+let writeArguments_initializer = {
+  displayNumber = -1;
+  regionBegin = 0;
+  regionSize = 0;
+  text = "";
+  attrAnd = [| |];
+  attrOr = [| |];
+  cursor = -1;
+  charset = ""
+}
+
+type handle
+
+let max_packet_size = 512
+
+type errorCode =
+  | SUCCESS
+  | NOMEM
+  | TTYBUSY
+  | DEVICEBUSY
+  | UNKNOWN_INSTRUCTION
+  | ILLEGAL_INSTRUCTION
+  | INVALID_PARAMETER
+  | INVALID_PACKET
+  | CONNREFUSED
+  | OPNOTSUPP
+  | GAIERR of int
+  | LIBCERR of Unix.error
+  | UNKNOWNTTY
+  | PROTOCOL_VERSION
+  | EOF
+  | EMPTYKEY
+  | DRIVERERROR
+  | AUTHENTICATION
+  | Unknown of int
+
+type error = {
+  brlerrno : int;
+  libcerrno : int;
+  gaierrno : int;
+  errfun : string;
+}
+
+external errorCode_of_error :
+  error -> errorCode = "brlapiml_errorCode_of_error"
+
+external strerror :
+  error -> string = "brlapiml_strerror"
+
+exception Brlapi_error of error
+exception Brlapi_exception of errorCode * int32 * string
+
+external openConnection :
+  settings -> Unix.file_descr * settings = "brlapiml_openConnection"
+external openConnectionWithHandle :
+  settings -> handle = "brlapiml_openConnectionWithHandle"
+external closeConnection :
+  ?h:handle -> unit -> unit = "brlapiml_closeConnection"
+external getDriverName :
+  ?h:handle -> unit -> string = "brlapiml_getDriverName"
+external getDisplaySize :
+  ?h:handle -> unit -> int * int = "brlapiml_getDisplaySize"
+
+external enterTtyMode :
+  ?h:handle -> int -> string -> int = "brlapiml_enterTtyMode"
+external enterTtyModeWithPath :
+  ?h:handle -> int array -> string -> int = "brlapiml_enterTtyModeWithPath"
+external leaveTtyMode :
+  ?h:handle -> unit -> unit = "brlapiml_leaveTtyMode"
+external setFocus :
+  ?h:handle -> int -> unit = "brlapiml_setFocus"
+
+external writeText :
+  ?h:handle -> int -> string -> unit = "brlapiml_writeText"
+external writeDots :
+  ?h:handle -> int array -> unit = "brlapiml_writeDots"
+external write :
+  ?h:handle -> writeArguments -> unit = "brlapiml_write"
+
+external readKey :
+  ?h:handle -> unit -> int64 option = "brlapiml_readKey"
+external waitKey :
+  ?h:handle -> unit -> int64 = "brlapiml_waitKey"
+
+type expandedKeyCode = {
+  type_ : int32;
+  command : int32;
+  argument : int32;
+  flags : int32
+}
+
+external expandKeyCode :
+  ?h:handle -> int64 -> expandedKeyCode = "brlapiml_expandKeyCode"
+
+type rangeType =
+  | RT_all
+  | RT_type
+  | RT_command
+  | RT_key
+  | RT_code
+
+external ignoreKeys :
+  ?h:handle -> rangeType -> int64 array -> unit = "brlapiml_ignoreKeys"
+external acceptKeys :
+  ?h:handle -> rangeType -> int64 array -> unit = "brlapiml_acceptKeys"
+external ignoreAllKeys :
+  ?h:handle -> unit = "brlapiml_ignoreAllKeys"
+external acceptAllKeys :
+  ?h:handle -> unit = "brlapiml_acceptAllKeys"  
+external ignoreKeyRanges :
+  ?h:handle -> (int64 * int64) array -> unit = "brlapiml_ignoreKeyRanges"
+external acceptKeyRanges :
+  ?h:handle -> (int64 * int64) array -> unit = "brlapiml_acceptKeyRanges"
+
+external enterRawMode :
+  ?h:handle -> string -> unit = "brlapiml_enterRawMode"
+external leaveRawMode :
+  ?h:handle -> unit -> unit = "brlapiml_leaveRawMode"
+external sendRaw :
+  ?h:handle -> string -> int = "brlapiml_sendRaw"
+external recvRaw :
+  ?h:handle -> unit -> string = "brlapiml_recvRaw"
+  
+external suspendDriver :
+  ?h:handle -> string -> unit = "brlapiml_suspendDriver"
+external resumeDriver :
+  ?h:handle -> unit -> unit = "brlapiml_resumeDriver"
+
+module type KEY = sig
+  type key
+  val key_of_int64 : int64 -> key
+  val int64_of_key : key -> int64
+end
+
+module MakeKeyHandlers (M1 : KEY) = struct
+  type key = M1.key
+  let readKey ?h () = match readKey ?h () with
+    | None -> None
+    | Some x -> Some (M1.key_of_int64 x)
+
+  let waitKey ?h () = M1.key_of_int64 (waitKey ?h ()) 
+  let ignoreKeys ?h t a = ignoreKeys ?h t (Array.map M1.int64_of_key a)
+  let acceptKeys ?h t a = acceptKeys ?h t (Array.map M1.int64_of_key a)
+  let f (x,y) = (M1.int64_of_key x, M1.int64_of_key y)
+  let g a = Array.map f a
+  let ignoreKeyRanges ?h a = ignoreKeyRanges ?h (g a)
+  let acceptKeyRanges ?h a = acceptKeyRanges ?h (g a)
+end
+
+  
+
+external setExceptionHandler :
+  unit -> unit = "brlapiml_setExceptionHandler"
+
+let _ =
+  let x = { brlerrno = 0; libcerrno = 0; gaierrno = 0; errfun = "" } in
+  Callback.register_exception "Brlapi_error"
+    (Brlapi_error x);
+  Callback.register_exception "Brlapi_exception"
+    (Brlapi_exception (SUCCESS, 0l, ""));
+  setExceptionHandler()

grub-core/braille/brltty/Bindings/OCaml/main.mli

@@ -0,0 +1,222 @@
+(*
+ * libbrlapi - A library providing access to braille terminals for applications.
+ *
+ * Copyright (C) 2002-2012 by
+ *   Sébastien Hinderer <Sebastien.Hinderer@ens-lyon.org>
+ *   Samuel Thibault <Samuel.Thibault@ens-lyon.org>
+ * All rights reserved.
+ *
+ * libbrlapi comes with ABSOLUTELY NO WARRANTY.
+ *
+ * This is free software, placed 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. Please see the file LICENSE-LGPL for details.
+ *
+ * Web Page: http://mielke.cc/brltty/
+ *
+ * This software is maintained by Dave Mielke <dave@mielke.cc>.
+ *)
+
+(* BrlAPI Interface for the OCaml language *)
+(*
+Ajouter des fichiers .in
+*)
+
+(*
+BRLAPI_RELEASE
+BRLAPI_MAJOR
+BRLAPI_MINOR
+BRLAPI_REVISION
+Faire un fichier .in: @VAR@ est remplacé par la valeur de VAR
+telle que définie dans configure.ac.
+*)
+
+(*
+BRLAPI_SOCKETPORTNUM
+BRLAPI_SOCKETPORT (string)
+BRLAPI_MAXPACKETSIZE
+BRLAPI_MAXNAMELENGTH
+BRLAPI_SOCKETPATH
+BRLAPI_ETCDIR
+BRLAPI_AUTHKEYFILE
+BRLAPI_DEFAUTH
+Idem que précédemmment
+C'est du ni<eau proto. Faut-il binder ?
+*)
+
+type settings = {
+  auth : string;
+  host : string
+}
+
+val settings_initializer : settings
+
+type writeArguments = {
+  mutable displayNumber : int;
+  mutable regionBegin : int;
+  mutable regionSize : int;
+  text : string;
+  attrAnd : int array;
+  attrOr : int array;
+  mutable cursor : int;
+  mutable charset : string
+}
+
+val writeArguments_initializer : writeArguments
+
+type handle
+
+val max_packet_size : int
+
+type errorCode =
+  | SUCCESS
+  | NOMEM
+  | TTYBUSY
+  | DEVICEBUSY
+  | UNKNOWN_INSTRUCTION
+  | ILLEGAL_INSTRUCTION
+  | INVALID_PARAMETER
+  | INVALID_PACKET
+  | CONNREFUSED
+  | OPNOTSUPP
+  | GAIERR of int
+  | LIBCERR of Unix.error
+  | UNKNOWNTTY
+  | PROTOCOL_VERSION
+  | EOF
+  | EMPTYKEY
+  | DRIVERERROR
+  | AUTHENTICATION
+  | Unknown of int
+
+type error = {
+  brlerrno : int;
+  libcerrno : int;
+  gaierrno : int;
+  errfun : string;
+}
+
+external errorCode_of_error :
+  error -> errorCode = "brlapiml_errorCode_of_error"
+
+external strerror :
+  error -> string = "brlapiml_strerror"
+
+exception Brlapi_error of error
+exception Brlapi_exception of errorCode * int32 * string
+
+external openConnection :
+  settings -> Unix.file_descr * settings = "brlapiml_openConnection"
+external openConnectionWithHandle :
+  settings -> handle = "brlapiml_openConnectionWithHandle"
+external closeConnection :
+  ?h:handle -> unit -> unit = "brlapiml_closeConnection"
+(*
+val expandHost : string -> string * string
+Idem: proto
+*)
+external getDriverName :
+  ?h:handle -> unit -> string = "brlapiml_getDriverName"
+external getDisplaySize :
+  ?h:handle -> unit -> int * int = "brlapiml_getDisplaySize"
+
+external enterTtyMode :
+  ?h:handle -> int -> string -> int = "brlapiml_enterTtyMode"
+val enterTtyModeWithPath :
+  ?h:handle -> int array -> string -> int
+external leaveTtyMode :
+  ?h:handle -> unit -> unit = "brlapiml_leaveTtyMode"
+external setFocus :
+  ?h:handle -> int -> unit = "brlapiml_setFocus"
+
+external writeText :
+  ?h:handle -> int -> string -> unit = "brlapiml_writeText"
+(* Arg optionnel pour curseur ? *)
+external writeDots :
+  ?h:handle -> int array -> unit = "brlapiml_writeDots"
+external write :
+  ?h:handle -> writeArguments -> unit = "brlapiml_write"
+
+(*
+BRLAPI_KEYCODE_MAX
+Les constantes pour travailler sur les flags de touches ?
+Les KEY_SYM ?
+Oui: pour être cohérent avec le fait de fournir le int64
+Flags: entiers.
+*)
+
+(* val getKeyName : expandedKeyCode -> string *)
+
+(*
+brlapi_dotNumberToBit
+brlapi_dotBitToNumber
+Unicode ?
+Oui, utile pour les key_sym
+*)
+
+external readKey :
+  ?h:handle -> unit -> int64 option = "brlapiml_readKey"
+external waitKey :
+  ?h:handle -> unit -> int64 = "brlapiml_waitKey"
+
+type expandedKeyCode = {
+  type_ : int32;
+  command : int32;
+  argument : int32;
+  flags : int32
+}
+
+external expandKeyCode :
+  ?h:handle -> int64 -> expandedKeyCode = "brlapiml_expandKeyCode"
+
+type rangeType =
+  | RT_all
+  | RT_type
+  | RT_command
+  | RT_key
+  | RT_code
+
+external ignoreKeys :
+  ?h:handle -> rangeType -> int64 array -> unit = "brlapiml_ignoreKeys"
+external acceptKeys :
+  ?h:handle -> rangeType -> int64 array -> unit = "brlapiml_acceptKeys"
+external ignoreAllKeys :
+  ?h:handle -> unit = "brlapiml_ignoreAllKeys"
+external acceptAllKeys :
+  ?h:handle -> unit = "brlapiml_acceptAllKeys"  
+external ignoreKeyRanges :
+  ?h:handle -> (int64 * int64) array -> unit = "brlapiml_ignoreKeyRanges"
+external acceptKeyRanges :
+  ?h:handle -> (int64 * int64) array -> unit = "brlapiml_acceptKeyRanges"
+
+external enterRawMode :
+  ?h:handle -> string -> unit = "brlapiml_enterRawMode"
+external leaveRawMode :
+  ?h:handle -> unit -> unit = "brlapiml_leaveRawMode"
+external sendRaw :
+  ?h:handle -> string -> int = "brlapiml_sendRaw"
+external recvRaw :
+  ?h:handle -> unit -> string = "brlapiml_recvRaw"
+
+external suspendDriver :
+  ?h:handle -> string -> unit = "brlapiml_suspendDriver"
+external resumeDriver :
+  ?h:handle -> unit -> unit = "brlapiml_resumeDriver"
+
+module type KEY = sig
+  type key
+  val key_of_int64 : int64 -> key
+  val int64_of_key : key -> int64
+end
+
+module MakeKeyHandlers (M1 : KEY) : sig
+  type key = M1.key
+  val readKey : ?h:handle -> unit -> key option
+  val waitKey : ?h:handle -> unit -> key
+
+  val ignoreKeys : ?h:handle -> rangeType -> key array -> unit
+  val acceptKeys : ?h:handle -> rangeType -> key array -> unit
+  val ignoreKeyRanges : ?h:handle -> (key * key) array -> unit
+  val acceptKeyRanges : ?h:handle -> (key * key) array -> unit
+end