hre_api.c

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

/* 
 *  hre_api.c:        Implementation of HRE API
 *  Author:           James &
 *  Created On:       Wed Dec  9 13:49:14 1992
 *  Last Modified By: James Kempf
 *  Last Modified On: Fri Sep 23 13:49:04 1994
 *  Update Count:     137
 *  Copyright (c) 1994 by Sun Microsystems Computer Company
 *  All rights reserved.
 *  
 *  Use and copying of this software and preparation of 
 *  derivative works based upon this software are permitted.
 *  Any distribution of this software or derivative works
 *  must comply with all applicable United States export control
 *  laws.
 *
 *  This software is made available as is, and Sun Microsystems
 *  Computer Company makes no warranty about the software, its
 *  performance, or its conformity to any specification
 */


#include <sys/types.h>
#ifdef ELX
#include <vxWorks.h>
#endif
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <locale.h>
#include <stdlib.h>
/*#include <libintl.h>*/
#include "hre_internal.h"	/* includes hre.h */

/* ari -- prototype for rii function */
recognizer __recognizer_internal_initialize(rec_info * ri);

/*Version number of API.*/

char *REC_VERSION = "2.0";

/*Domain name for internationalized text.*/

#define INTL_DOMAIN "recognition_manager"

/* XXX -- Intl Hack -- Jay & Ari */
#define	dgettext(domain, msg)	(msg)
#define	bindtextdomain(dirname,	domain)

/*
 * These magic numbers are used to ensure the integrity of the
 * recognizer structure.
*/


#define REC_MAGIC       0xfeed
#define REC_END_MAGIC   0xbeef

/*Check the recognizer for validity*/

#define RI_CHECK_MAGIC(rec) \
  ( (rec != NULL) && \
    (((recognizer)rec)->recognizer_magic == REC_MAGIC) && \
   (((recognizer)rec)->recognizer_end_magic == REC_END_MAGIC) &&\
   (((recognizer)rec)->recognizer_version == REC_VERSION) )

/*The name of the initialization & finalization functions.*/

/* static char rii_name[] = "__recognizer_internal_initialize";
static char rif_name[] = "__recognizer_internal_finalize";  */

/*User home directory for recognizer info.*/
/* ari -- changed USERRECHOME from ".recognizers" */
#define HOME "HOME"
#define USERRECHOME ".classifiers"

/*Local functions*/

//static char* shared_library_name(char* directory,char* locale,char* name);
static rec_info *make_rec_info(char *directory, char *name, char **subset);
static void delete_rec_info(rec_info * ri);
//static int check_for_user_home();
static void intl_initialize();

static void cleanup_rec_element(rec_element * re, bool delete_points_p);
void error(char *);

/*The last error.*/

static char *the_last_error = NULL;

static char *
safe_malloc(int nbytes)
{
    char *res = malloc(nbytes);
    if (res == NULL) {
	error("malloc failure");
	exit(2);
    }
    return (res);
}


/*
 * Implementation of API functions
*/

/*
 * recognizer_load - Load the recognizer matching the rec_info struct.
 * If name is not null, then load the recognizer having that name. Returns
 * the recognizer object, or null if it can't load the recognizer, and
 * sets errno to indicate why.
*/

recognizer
recognizer_load(char *directory, char *name, char **subset)
{
    recognizer rec;		/*the recognizer */
    //recognizer_internal_initialize rii; /*the initialization function*/
    rec_info *rinf;		/*rec_info for recognizer information */
    static bool intl_init = false;	/*true if recog. manager initted. */

    if (intl_init == false) {
	intl_init = true;

	intl_initialize();
    }

    /*The name takes precedence. */
    rinf = make_rec_info(directory, name, subset);
    if (rinf == NULL) {
	the_last_error =
	    dgettext(INTL_DOMAIN,
		     "Ran out of memory during prelinking initialization.");
	return ((recognizer) NULL);
    }
//fprintf(stderr, "Got past make_rec_info.\n");

    /*Let recognition code create recognizer and initialize */
    rec = __recognizer_internal_initialize(rinf);
    if (rec == NULL) {
	return ((recognizer) NULL);
    }
//fprintf(stderr, "Did rii.\n");
    /*Check whether it's been correctly initialized */

    if (rec->recognizer_load_state == NULL ||
	rec->recognizer_save_state == NULL ||
	rec->recognizer_load_dictionary == NULL ||
	rec->recognizer_save_dictionary == NULL ||
	rec->recognizer_free_dictionary == NULL ||
	rec->recognizer_add_to_dictionary == NULL ||
	rec->recognizer_delete_from_dictionary == NULL ||
	rec->recognizer_error == NULL ||
	rec->recognizer_set_context == NULL ||
	rec->recognizer_get_context == NULL ||
	rec->recognizer_clear == NULL ||
	rec->recognizer_get_buffer == NULL ||
	rec->recognizer_set_buffer == NULL ||
	rec->recognizer_translate == NULL ||
	rec->recognizer_get_extension_functions == NULL ||
	rec->recognizer_get_gesture_names == NULL ||
	rec->recognizer_set_gesture_action == NULL) {

	recognizer_unload(rec);
	fprintf(stderr, "Unloading b/c null function pointer.\n");
	the_last_error =
	    dgettext(INTL_DOMAIN,
		     "One or more recognizer function pointers is NULL.");
	return ((recognizer) NULL);
    }


    /*Set the rec_info structure. */

    rec->recognizer_info = rinf;

    /*Check whether home directory is there for recognizer info. */

/*
 *  ari -- don't bother.  We're not going to load from each user's
 *  home directory at this point.  Instead, we'll use a stupid
 *  little a-b-c file because it loads FAST.
 *
 *    if( check_for_user_home() < 0 ) {
 *	recognizer_unload(rec);
 *	return((recognizer)NULL);
 *   }
 */
    /*We got it! */
//fprintf(stderr, "Done.\n");

    return (rec);
}

/*
 * recognizer_unload - Unload the recognizer.
*/

int
recognizer_unload(recognizer rec)
{
    //recognizer_internal_finalize rif;

    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    __recognizer_internal_finalize(rec);

    return (0);
}

/*
 * recognizer_load_state-Get any recognizer state associated with name
 * in dir. Note that name may not be simple file name, since
 * there may be more than one file involved. Return 0 if successful,
 * -1 if not.
*/

int
recognizer_load_state(recognizer rec, char *dir, char *name)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_load_state(rec, dir, name));
}

/*
 * recognizer_save_state-Save any recognizer state to name
 * in dir. Note that name may not be a simple file name, since
 * there may be more than one file involved. Return 0 if successful,
 * -1 if not.
*/

int
recognizer_save_state(recognizer rec, char *dir, char *name)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_save_state(rec, dir, name));
}

/*
 * recognizer_load_dictionary-Load dictionary, return pointer
 * to it, or NULL if error.
*/

wordset
recognizer_load_dictionary(recognizer rec, char *dir, char *name)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (NULL);
    }

    /*Do the function. */

    return (rec->recognizer_load_dictionary(rec, dir, name));
}

/*
 * recognizer_save_dictionary-Save the  dictionary to the file, return 0 if
 * OK, -1 if error.
*/

int
recognizer_save_dictionary(recognizer rec, char *dir, char *name,
			   wordset dict)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_save_dictionary(rec, dir, name, dict));
}

/*
 * recognizer_free_dictionary-Free the dictionary, return 0 if
 * OK, -1 if error.
*/

int
recognizer_free_dictionary(recognizer rec, wordset dict)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_free_dictionary(rec, dict));
}

/*
 * recognizer_add_to_dictionary-Add word to the dictionary,
 * return 0 if OK, -1 if error.
*/


int
recognizer_add_to_dictionary(recognizer rec, letterset * word, wordset dict)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_add_to_dictionary(rec, word, dict));
}

/*
 * recognizer_delete_from_dictionary-Delete word from the dictionary,
 * return 0 if OK, -1 if error.
*/

int
recognizer_delete_from_dictionary(recognizer rec, letterset * word,
				  wordset dict)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_delete_from_dictionary(rec, word, dict));
}

/*
 * recognizer_get_info-Get a pointers to the rec_info
 * giving the locales and subsets supported by the recognizer
 * and the shared library pathname.
*/

const rec_info *
recognizer_get_info(recognizer rec)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return ((rec_info *) NULL);
    }

    /*Return the rec_info object. */

    return (rec->recognizer_info);
}

/*
 * recognizer_manager_version-Return the version number string of the
 * recognition manager.
*/

const char *
recognizer_manager_version(recognizer rec)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (NULL);
    }

    return (rec->recognizer_version);

}

/*
 * recognizer_error-Return the last error message, or NULL if none.
*/

char *
recognizer_error(recognizer rec)
{

    /*Make sure magic numbers right and function there. */

    if (!RI_CHECK_MAGIC(rec) && the_last_error == NULL) {
	return (dgettext(INTL_DOMAIN, "Bad recognizer object."));

    } else if (the_last_error != NULL) {
	char *error = the_last_error;

	the_last_error = NULL;
	return (error);
    }

    /*Do the function. */

    return (rec->recognizer_error(rec));
}

/*
 * recognizer_set_context-Set the recognition context for translation.
 * Return 0 if successful, -1 if error.
*/

int
recognizer_set_context(recognizer rec, rc * rec_xt)
{

    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_set_context(rec, rec_xt));
}

/* 
 * recognzier_get_context-Get the recognition context for translation.
 * If none or error, return NULL.
*/

rc *
recognizer_get_context(recognizer rec)
{

    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (NULL);
    }

    /*Do the function. */

    return (recognizer_get_context(rec));
}

/*
 * recognizer_clear-Clear buffer and recognition context.
 * Return 0 if success, else -1.
*/

int
recognizer_clear(recognizer rec, bool delete_points_p)
{

    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_clear(rec, delete_points_p));
}

/*recognizer_get_buffer-Get stroke buffer. Return 0 if success, else -1.*/


int
recognizer_get_buffer(recognizer rec, u_int * nstrokes, pen_stroke ** strokes)
{

    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_get_buffer(rec, nstrokes, strokes));

}

/*
 * recognizer_set_buffer-Set stroke buffer to arg. Return 0 if success, else 
 * return -1.
*/

int
recognizer_set_buffer(recognizer rec, u_int nstrokes, pen_stroke * strokes)
{

    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (-1);
    }

    /*Do the function. */

    return (rec->recognizer_set_buffer(rec, nstrokes, strokes));

}

/*
 * recognizer_translate-Translate the strokes in the current context, including
 * buffered strokes. If nstrokes == 0 or strokes == NULL, return 
 * translation of stroke buffer.
*/

int
recognizer_translate(recognizer rec,
		     u_int nstrokes,
		     pen_stroke * strokes,
		     bool correlate_p, int *nret, rec_alternative ** ret)
{
    int retval;
    char msg[80];
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, msg);
	return (-1);
    }

/* ari */
/*    {
 *      u_int i;
 *      pen_stroke ari_pstr;
 *      pen_point* ari_pts;
 *      int ari;
 *      for (i = 0; i < nstrokes; i++) {
 *	ari_pstr = strokes[i];
 *	ari_pts = ari_pstr.ps_pts;
 *	fprintf(stderr, "\nrecognizer_translate: ari_pts = %ld, sizeof(Time) = %d, sizeof(ari_pts[0] = %d, %d points are...\n", ari_pts, sizeof(Time), sizeof(ari_pts[0]), ari_pstr.ps_npts);
 *	for (ari = 0; ari < ari_pstr.ps_npts; ari++)
 *	   fprintf(stderr, "%ld -- (%d, %d)  ", ari_pts[ari], ari_pts[ari].x, ari_pts[ari].y);
 *      }
 *    }     
*/
    /*Do the function. */
/* ari -- this is calling cmu_recognizer_translate */
    retval = rec->recognizer_translate(rec,
				       nstrokes,
				       strokes, correlate_p, nret, ret);
    return (retval);
}


/*
 * recognizer_get_extension_functions-Return a null terminated array
 * of functions providing extended functionality. Their interfaces
 * will change depending on the recognizer.
*/

rec_fn *
recognizer_get_extension_functions(recognizer rec)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return ((rec_fn *) NULL);
    }

    /*Do the function. */

    return (rec->recognizer_get_extension_functions(rec));
}


/*
 * recognizer_get_gesture_names - Return a null terminated array of
 * gesture name strings.
*/

char **
recognizer_get_gesture_names(recognizer rec)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return (NULL);
    }

    /*Do the function. */

    return (rec->recognizer_get_gesture_names(rec));
}

/*
 * recognizer_set_gesture_action-Set the action function for the gesture.
*/

xgesture
recognizer_train_gestures(recognizer rec, char *name, xgesture fn,
			  void *wsinfo)
{
    /*Make sure magic numbers right. */

    if (!RI_CHECK_MAGIC(rec)) {
	the_last_error = dgettext(INTL_DOMAIN, "Bad recognizer object.");
	return ((xgesture) - 1);
    }

    /*Do the function. */

    return (rec->recognizer_set_gesture_action(rec, name, fn, wsinfo));
}

/*
 * Local functions.
*/

/*
 * shared_library_name-Get the full pathname to the shared library,
 *    based on the recognizer name and the environment.
*/


#if 0
static char *
shared_library_name(char *directory, char *locale, char *name)
{
    char *ret = NULL;
    int len = strlen(name);

    /*If directory is there, it takes precedence. */

    if (directory != NULL) {
	ret = (char *) safe_malloc(strlen(directory) + len + 2);
	strcpy(ret, directory);
	strcat(ret, "/");
	strcat(ret, name);

    } else {
	char *dir = NULL;

	/*First try the environment variable. */

	if ((dir = getenv(RECHOME)) == NULL) {
	    dir = "REC_DEFAULT_HOME_DIR";

	}

	ret = (char *) safe_malloc(strlen(dir) + strlen(locale) + len + 3);
	/*Form the pathname. */
	strcpy(ret, dir);
	strcat(ret, "/");
	strcat(ret, locale);
	strcat(ret, "/");
	strcat(ret, name);

    }

    return (ret);
}
#endif

/*
 * intl_initialize-Initialize the internationaliztion of messages for
 * the recognition manager.
*/

static void
intl_initialize()
{
    char *dirname;

    /*Get recognizer home directory name from environment. */

    if ((dirname = getenv(RECHOME)) == NULL) {
	dirname = "REC_DEFAULT_HOME_DIR";
    }

    /*Bind the text domain. */

    bindtextdomain(dirname, INTL_DOMAIN);
}


/*make_rec_info-Create a rec_info structure*/

static rec_info *
make_rec_info(char *directory, char *name, char **subset)
{
    int i, len;
    rec_info *ri;
    char *locale;

    ri = (rec_info *) safe_malloc(sizeof(rec_info));
    ri->ri_locale = NULL;
    ri->ri_name = NULL;
    ri->ri_subset = NULL;

    /*Get locale */

    if ((locale = getenv(LANG)) == NULL) {
	locale = strdup(REC_DEFAULT_LOCALE);
    }

    if ((ri->ri_locale = strdup(locale)) == NULL) {
	delete_rec_info(ri);