/* liblouis Braille Translation and Back-Translation Library

   Based on the Linux screenreader BRLTTY, copyright (C) 1999-2006 by The
   BRLTTY Team

   Copyright (C) 2004, 2005, 2006 ViewPlus Technologies, Inc. www.viewplus.com
   Copyright (C) 2004, 2005, 2006 JJB Software, Inc. www.jjb-software.com
   Copyright (C) 2016 Mike Gray, American Printing House for the Blind
   Copyright (C) 2016 Davy Kager, Dedicon

   This file is part of liblouis.

   liblouis 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.

   liblouis 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with liblouis. If not, see <http://www.gnu.org/licenses/>.
*/

/**
 * @file
 * @brief Internal API of liblouis
 */

#ifndef __LOUIS_H_
#define __LOUIS_H_

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#include <stdio.h>
#include "liblouis.h"

/* Unlike Windows, Mingw can handle forward slashes as directory
   separator, see http://mingw.org/wiki/Posix_path_conversion */
#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__MINGW64__)
#define PATH_SEP ';'
#define DIR_SEP '\\'
#else
#define PATH_SEP ':'
#define DIR_SEP '/'
#endif

#ifdef _MSC_VER
#define strcasecmp _stricmp
#endif

#define NUMVAR 50
#define EMPHMODECHARSSIZE 256
#define NOEMPHCHARSSIZE 256
#define LETSIGNSIZE 256
// noletsignbefore and noletsignafter is hardly ever used and usually
// only with very few chars, so it only needs a small array
#define LETSIGNBEFORESIZE 64
#define LETSIGNAFTERSIZE 64
#define SEQPATTERNSIZE 128
#define CHARSIZE sizeof(widechar)
#define DEFAULTRULESIZE 50

typedef struct intCharTupple {
	unsigned long long key;
	char value;
} intCharTupple;

/* HASHNUM must be prime */
#define HASHNUM 1123

#define MAXPASS 4
#define MAXSTRING 2048
#define MAX_MACRO_VAR 100  // maximal number of variable substitutions a macro can contain
#define MAX_EMPH_CLASSES 10	  // maximal number of emphasis classes
#define MAX_MODES 6			  // maximal number of modes that can be handled
#define MAX_SOURCE_FILES 100  // maximal number of files a table can consist of

typedef unsigned int TranslationTableOffset;

/* Basic type for translation table data, which carries all alignment
 * constraints that fields contained in translation table may have.
 * Notably TranslationTableCharacterAttributes is unsigned long long, so we need
 * at least this big basic type. */
typedef unsigned long long TranslationTableData;
#define OFFSETSIZE sizeof(TranslationTableData)

typedef enum {
	/* The first 8 are the predefined character classes. They need to be listed first and
	   in this order because of how allocateCharacterClasses works. */
	CTC_Space = 0x1,
	CTC_Letter = 0x2,
	CTC_Digit = 0x4,
	CTC_Punctuation = 0x8,
	CTC_UpperCase = 0x10,
	CTC_LowerCase = 0x20,
	CTC_Math = 0x40,
	CTC_Sign = 0x80,
	CTC_LitDigit = 0x100,
	CTC_CapsMode = 0x200,
	// bit 0x400 used to be taken by CTC_EmphMode
	CTC_NumericMode = 0x800,
	CTC_NumericNoContract = 0x1000,
	CTC_SeqDelimiter = 0x2000,
	CTC_SeqBefore = 0x4000,
	CTC_SeqAfter = 0x8000,
	/* The following 8 are reserved for %0 to %7 (in no particular order) */
	/* Be careful with changing these values (and also CTC_EndOfInput) because in
	   pattern_compile_expression they are stored in a unsigned int after cutting off the
	   16 least significant bits. */
	CTC_UserDefined1 = 0x10000,
	CTC_UserDefined2 = 0x20000,
	CTC_UserDefined3 = 0x40000,
	CTC_UserDefined4 = 0x80000,
	CTC_UserDefined5 = 0x100000,
	CTC_UserDefined6 = 0x200000,
	CTC_UserDefined7 = 0x400000,
	CTC_UserDefined8 = 0x800000,
	CTC_EndOfInput = 0x1000000,	 // only used by pattern matcher
	CTC_EmpMatch = 0x2000000,	 // only used in TranslationTableRule->before and
								 // TranslationTableRule->after
	CTC_MidEndNumericMode = 0x4000000,
	/* At least 37 more bits available in an unsigned long long (at least 64 bits). Used
	   for custom attributes 9 to 45. These need to be the last values of the enum. */
	CTC_UserDefined9 = 0x8000000,
	CTC_UserDefined10 = 0x10000000,
	CTC_UserDefined11 = 0x20000000,
	CTC_UserDefined12 = 0x40000000,
} TranslationTableCharacterAttribute;

typedef enum {
	pass_first = '`',
	pass_last = '~',
	pass_lookback = '_',
	pass_string = '\"',
	pass_dots = '@',
	pass_omit = '?',
	pass_startReplace = '[',
	pass_endReplace = ']',
	pass_startGroup = '{',
	pass_endGroup = '}',
	pass_variable = '#',
	pass_not = '!',
	pass_search = '/',
	pass_any = 'a',
	pass_digit = 'd',
	pass_litDigit = 'D',
	pass_letter = 'l',
	pass_math = 'm',
	pass_punctuation = 'p',
	pass_sign = 'S',
	pass_space = 's',
	pass_uppercase = 'U',
	pass_lowercase = 'u',
	pass_class1 = 'w',
	pass_class2 = 'x',
	pass_class3 = 'y',
	pass_class4 = 'z',
	pass_attributes = '$',
	pass_groupstart = '{',
	pass_groupend = '}',
	pass_groupreplace = ';',
	pass_swap = '%',
	pass_hyphen = '-',
	pass_until = '.',
	pass_eq = '=',
	pass_lt = '<',
	pass_gt = '>',
	pass_endTest = 32,
	pass_plus = '+',
	pass_copy = '*',
	pass_leftParen = '(',
	pass_rightParen = ')',
	pass_comma = ',',
	pass_lteq = 130,
	pass_gteq = 131,
	pass_invalidToken = 132,
	pass_noteq = 133,
	pass_and = 134,
	pass_or = 135,
	pass_nameFound = 136,
	pass_numberFound = 137,
	pass_boolean = 138,
	pass_class = 139,
	pass_define = 140,
	pass_emphasis = 141,
	pass_group = 142,
	pass_mark = 143,
	pass_repGroup = 143,
	pass_script = 144,
	pass_noMoreTokens = 145,
	pass_replace = 146,
	pass_if = 147,
	pass_then = 148,
	pass_all = 255
} pass_Codes;

typedef unsigned long long TranslationTableCharacterAttributes;

typedef struct {
	TranslationTableOffset next;
	widechar lookFor;
	widechar found;
} CharDotsMapping;

typedef struct {
	const char *sourceFile;
	int sourceLine;
	TranslationTableOffset next;
	TranslationTableOffset definitionRule;
	TranslationTableOffset otherRules;
	TranslationTableCharacterAttributes attributes;
	TranslationTableCharacterAttributes mode;
	TranslationTableOffset compRule;
	widechar value;
	TranslationTableOffset basechar;
	TranslationTableOffset linked;
	int ruleIndex; /** sequence number of rule within table */
	int finalized;
} TranslationTableCharacter;

typedef enum { /* Op codes */
	CTO_IncludeFile,
	CTO_Locale, /* Deprecated, do not use */
	CTO_Undefined,
	/* Do not change the order of the following opcodes! */
	CTO_CapsLetter,
	CTO_BegCapsWord,
	CTO_EndCapsWord,
	CTO_BegCaps,
	CTO_EndCaps,
	CTO_BegCapsPhrase,
	CTO_EndCapsPhrase,
	CTO_LenCapsPhrase,
	CTO_ModeLetter,
	CTO_BegModeWord,
	CTO_EndModeWord,
	CTO_BegMode,
	CTO_EndMode,
	CTO_BegModePhrase,
	CTO_EndModePhrase,
	CTO_LenModePhrase,
	/* End of ordered opcodes */
	CTO_LetterSign,
	CTO_NoLetsignBefore,
	CTO_NoLetsign,
	CTO_NoLetsignAfter,
	CTO_NumberSign,
	CTO_NoNumberSign,
	CTO_NumericModeChars,
	CTO_MidEndNumericModeChars,
	CTO_NumericNoContractChars,
	CTO_SeqDelimiter,
	CTO_SeqBeforeChars,
	CTO_SeqAfterChars,
	CTO_SeqAfterPattern,
	CTO_SeqAfterExpression,
	CTO_EmphClass,

	/* Do not change the order of the following opcodes! */
	CTO_EmphLetter,
	CTO_BegEmphWord,
	CTO_EndEmphWord,
	CTO_BegEmph,
	CTO_EndEmph,
	CTO_BegEmphPhrase,
	CTO_EndEmphPhrase,
	CTO_LenEmphPhrase,
	/* End of ordered opcodes */

	CTO_CapsModeChars,
	CTO_EmphModeChars,
	CTO_NoEmphChars,
	CTO_BegComp,
	CTO_EndComp,
	CTO_NoContractSign,
	CTO_MultInd,
	CTO_CompDots,
	CTO_Comp6,
	CTO_Class,	/* define a character class */
	CTO_After,	/* only match if after character in class */
	CTO_Before, /* only match if before character in class 30 */
	CTO_NoBack,
	CTO_NoFor,
	CTO_EmpMatchBefore,
	CTO_EmpMatchAfter,
	CTO_SwapCc,
	CTO_SwapCd,
	CTO_SwapDd,
	CTO_Space,
	CTO_Digit,
	CTO_Punctuation,
	CTO_Math,
	CTO_Sign,
	CTO_Letter,
	CTO_UpperCase,
	CTO_LowerCase,
	CTO_Grouping,
	CTO_UpLow,
	CTO_LitDigit,
	CTO_Display,
	CTO_Replace,
	CTO_Context,
	CTO_Correct,
	CTO_Pass2,
	CTO_Pass3,
	CTO_Pass4,
	CTO_Repeated,
	CTO_RepWord,
	CTO_RepEndWord,
	CTO_CapsNoCont,
	CTO_Always,
	CTO_ExactDots,
	CTO_NoCross,
	CTO_Syllable,
	CTO_NoCont,
	CTO_CompBrl,
	CTO_Literal,
	CTO_LargeSign,
	CTO_WholeWord,
	CTO_PartWord,
	CTO_JoinNum,
	CTO_JoinableWord,
	CTO_LowWord,
	CTO_Contraction,
	CTO_SuffixableWord, /** whole word or beginning of word */
	CTO_PrefixableWord, /** whole word or end of word */
	CTO_BegWord,		/** beginning of word only */
	CTO_BegMidWord,		/** beginning or middle of word */
	CTO_MidWord,		/** middle of word only 20 */
	CTO_MidEndWord,		/** middle or end of word */
	CTO_EndWord,		/** end of word only */
	CTO_PrePunc,		/** punctuation in string at beginning of word */
	CTO_PostPunc,		/** punctuation in string at end of word */
	CTO_BegNum,			/** beginning of number */
	CTO_MidNum,			/** middle of number, e.g., decimal point */
	CTO_EndNum,			/** end of number */
	CTO_DecPoint,
	CTO_Hyphen,
	// CTO_Apostrophe,
	// CTO_Initial,
	CTO_NoBreak,
	CTO_Match,
	CTO_BackMatch,
	CTO_Attribute,
	CTO_Base,
	CTO_Macro,
	CTO_None,

	/** "internal" opcodes */
	CTO_EndCapsPhraseBefore,
	CTO_EndCapsPhraseAfter,

	CTO_All
} TranslationTableOpcode;

typedef struct {
	const char *sourceFile;
	int sourceLine;
	int index;								   /** sequence number of rule within table */
	TranslationTableOffset charsnext;		   /** next chars entry */
	TranslationTableOffset dotsnext;		   /** next dots entry */
	TranslationTableCharacterAttributes after; /** character types which must follow */
	TranslationTableCharacterAttributes before; /** character types which must precede */
	TranslationTableOffset patterns;			/** before and after patterns */
	TranslationTableOpcode opcode; /** rule for testing validity of replacement */
	char nocross;
	short charslen;						 /** length of string to be replaced */
	short dotslen;						 /** length of replacement string */
	widechar charsdots[DEFAULTRULESIZE]; /** find and replacement strings */
} TranslationTableRule;

typedef struct /* state transition */
{
	widechar ch;
	widechar newState;
} HyphenationTrans;

typedef union {
	HyphenationTrans *pointer;
	TranslationTableOffset offset;
} PointOff;

typedef struct /* one state */
{
	PointOff trans;
	TranslationTableOffset hyphenPattern;
	widechar fallbackState;
	widechar numTrans;
} HyphenationState;

typedef struct CharacterClass {
	struct CharacterClass *next;
	TranslationTableCharacterAttributes attribute;
	widechar length;
	widechar name[1];
} CharacterClass;

typedef struct RuleName {
	struct RuleName *next;
	TranslationTableOffset ruleOffset;
	widechar length;
	widechar name[1];
} RuleName;

typedef struct {
	/* either typeform or mode should be set, not both */
	formtype typeform; /* corresponding value in "typeforms" enum */
	TranslationTableCharacterAttributes mode; /* corresponding character attribute */
	unsigned int value;						  /* bit field that contains a single "1" */
	unsigned short
			rule; /* emphasis rules (index in emphRules, emphModeChars and noEmphChars) */
} EmphasisClass;

typedef struct {
	TranslationTableOffset tableSize;
	TranslationTableOffset bytesUsed;
	TranslationTableOffset charToDots[HASHNUM];
	TranslationTableOffset dotsToChar[HASHNUM];
	TranslationTableData ruleArea[1]; /** Space for storing all rules and values */
} DisplayTableHeader;

/**
 * Translation table header
 */
typedef struct { /* translation table */

	/* state needed during compilation */
	TranslationTableOffset tableSize;
	TranslationTableOffset bytesUsed;
	CharacterClass *characterClasses;
	TranslationTableCharacterAttributes nextCharacterClassAttribute;
	TranslationTableCharacterAttributes nextNumberedCharacterClassAttribute;
	RuleName *ruleNames;
	TranslationTableCharacterAttributes
			numberedAttributes[8]; /* attributes 0-7 used in match rules (could also be
								   stored in `characterClasses', but this is slightly
								   faster) */
	int usesAttributeOrClass;	   /* 1 = attribute, 2 = class */
	char *sourceFiles[MAX_SOURCE_FILES + 1];
	int ruleCounter;

	/* needed for translation or other api functions */
	int finalized;
	int capsNoCont;
	int numPasses;
	int corrections;
	int syllables;
	int usesSequences;
	int usesNumericMode;
	int hasCapsModeChars;
	TranslationTableOffset undefined;
	TranslationTableOffset letterSign;
	TranslationTableOffset numberSign;
	TranslationTableOffset noContractSign;
	TranslationTableOffset noNumberSign;
	widechar seqPatterns[SEQPATTERNSIZE];
	char *emphClassNames[MAX_EMPH_CLASSES];
	EmphasisClass emphClasses[MAX_EMPH_CLASSES];
	EmphasisClass modes[MAX_MODES];
	int seqPatternsCount;
	widechar seqAfterExpression[SEQPATTERNSIZE];
	int seqAfterExpressionLength;
	TranslationTableOffset emphRules[MAX_EMPH_CLASSES + MAX_MODES]
									[9]; /* 9 is the size of the EmphCodeOffset enum */
	TranslationTableOffset begComp;
	TranslationTableOffset endComp;
	TranslationTableOffset hyphenStatesArray;
	widechar noLetsignBefore[LETSIGNBEFORESIZE];
	int noLetsignBeforeCount;
	widechar noLetsign[LETSIGNSIZE];
	int noLetsignCount;
	widechar noLetsignAfter[LETSIGNAFTERSIZE];
	int noLetsignAfterCount;
	widechar emphModeChars[MAX_EMPH_CLASSES] /* does not include caps: capsmodechars are
											  * currently stored as character attributes
											  */
						  [EMPHMODECHARSSIZE + 1];
	widechar noEmphChars[MAX_EMPH_CLASSES] /* does not include caps */
						[NOEMPHCHARSSIZE + 1];
	TranslationTableOffset characters[HASHNUM]; /** Character definitions */
	TranslationTableOffset dots[HASHNUM];		/** Dot definitions */
	TranslationTableOffset forPassRules[MAXPASS + 1];
	TranslationTableOffset backPassRules[MAXPASS + 1];
	TranslationTableOffset forRules[HASHNUM];  /** Chains of forward rules */
	TranslationTableOffset backRules[HASHNUM]; /** Chains of backward rules */
	TranslationTableData ruleArea[1]; /** Space for storing all rules and values */
} TranslationTableHeader;

typedef enum {
	alloc_typebuf,
	alloc_wordBuffer,
	alloc_emphasisBuffer,
	alloc_destSpacing,
	alloc_passbuf,
	alloc_posMapping1,
	alloc_posMapping2,
	alloc_posMapping3
} AllocBuf;

#define MAXPASSBUF 3

typedef enum {
	begPhraseOffset = 0,
	endPhraseBeforeOffset = 1,
	endPhraseAfterOffset = 2,
	begOffset = 3,
	endOffset = 4,
	letterOffset = 5,
	begWordOffset = 6,
	endWordOffset = 7,
	lenPhraseOffset = 8
} EmphCodeOffset;

/* Grouping the begin, end, word and symbol bits and using the type of
 * a single bit group for representing the emphasis classes allows us
 * to do simple bit operations. */

/* fields contain sums of EmphasisClass.value */
/* MAX_EMPH_CLASSES + MAX_MODES may not exceed 16 */
typedef struct {
	unsigned int begin : 16;
	unsigned int end : 16;
	unsigned int word : 16;
	unsigned int symbol : 16;
} EmphasisInfo;

typedef enum { noEncoding, bigEndian, littleEndian, ascii8 } EncodingType;

typedef struct {
	const char *fileName;
	const char *sourceFile;
	FILE *in;
	int lineNumber;
	EncodingType encoding;
	int status;
	int linelen;
	int linepos;
	int checkencoding[2];
	widechar line[MAXSTRING];
} FileInfo;

/* The following function definitions are hooks into
 * compileTranslationTable.c. Some are used by other library modules.
 * Others are used by tools like lou_allround.c and lou_debug.c. */

/**
 * Comma separated list of directories to search for tables.
 */
char *EXPORT_CALL
_lou_getTablePath(void);

/**
 * Resolve tableList against base.
 */
char **EXPORT_CALL
_lou_resolveTable(const char *tableList, const char *base);

/**
 * The default table resolver
 */
char **EXPORT_CALL
_lou_defaultTableResolver(const char *tableList, const char *base);

/**
 * Return single-cell dot pattern corresponding to a character.
 * TODO: move to commonTranslationFunctions.c
 */
widechar EXPORT_CALL
_lou_getDotsForChar(widechar c, const DisplayTableHeader *table);

/**
 * Return character corresponding to a single-cell dot pattern.
 * TODO: move to commonTranslationFunctions.c
 */
widechar EXPORT_CALL
_lou_getCharForDots(widechar d, const DisplayTableHeader *table);

void EXPORT_CALL
_lou_getTable(const char *tableList, const char *displayTableList,
		const TranslationTableHeader **translationTable,
		const DisplayTableHeader **displayTable);

const TranslationTableHeader *EXPORT_CALL
_lou_getTranslationTable(const char *tableList);

const DisplayTableHeader *EXPORT_CALL
_lou_getDisplayTable(const char *tableList);

int EXPORT_CALL
_lou_compileTranslationRule(const char *tableList, const char *inString);

int EXPORT_CALL
_lou_compileDisplayRule(const char *tableList, const char *inString);

/**
 * Allocate memory for internal buffers
 *
 * Used by lou_translateString.c and lou_backTranslateString.c ONLY
 * to allocate memory for internal buffers.
 * TODO: move to utils.c
 */
void *EXPORT_CALL
_lou_allocMem(AllocBuf buffer, int index, int srcmax, int destmax);

/**
 * Hash function for character strings
 *
 * @param lowercase Whether to convert the string to lowercase because
 *                  making the hash of it.
 */
unsigned long int EXPORT_CALL
_lou_stringHash(const widechar *c, int lowercase, const TranslationTableHeader *table);

/**
 * Hash function for single characters
 */
unsigned long int EXPORT_CALL
_lou_charHash(widechar c);

/**
 * Return a string in the same format as the characters operand in opcodes
 */
const char *EXPORT_CALL
_lou_showString(widechar const *chars, int length, int forceHex);

/**
 * Print out dot numbers
 *
 * @return a string containing the dot numbers. The longest possible
 * output is "\123456789ABCDEF0/"
 */
const char *EXPORT_CALL
_lou_unknownDots(widechar dots);

/**
 * Return a character string in the format of the dots operand
 */
const char *EXPORT_CALL
_lou_showDots(widechar const *dots, int length);

/**
 * Return a character string where the attributes are indicated
 * by the attribute letters used in multipass opcodes
 */
char *EXPORT_CALL
_lou_showAttributes(TranslationTableCharacterAttributes a);

/**
 * Return number of the opcode
 *
 * @param toFind the opcodes
 */
TranslationTableOpcode EXPORT_CALL
_lou_findOpcodeNumber(const char *tofind);

/**
 * Return the name of the opcode associated with an opcode number
 *
 * @param opcode an opcode
 */
const char *EXPORT_CALL
_lou_findOpcodeName(TranslationTableOpcode opcode);

/**
 * Convert string to wide characters
 *
 * Takes a character string and produces a sequence of wide characters.
 * Opposite of _lou_showString.
 *
 * @param inString the input string
 * @param outString the output wide char sequence
 * @return length of the widechar sequence.
 */
int EXPORT_CALL
_lou_extParseChars(const char *inString, widechar *outString);

/**
 * Convert string to wide characters containing dot patterns
 *
 * Takes a character string and produces a sequence of wide characters
 * containing dot patterns. Opposite of _lou_showDots.
 * @param inString the input string
 * @param outString the output wide char sequence
 * @return length of the widechar sequence.
 */
int EXPORT_CALL
_lou_extParseDots(const char *inString, widechar *outString);

int EXPORT_CALL
_lou_translate(const char *tableList, const char *displayTableList, const widechar *inbuf,
		int *inlen, widechar *outbuf, int *outlen, formtype *typeform, char *spacing,
		int *outputPos, int *inputPos, int *cursorPos, int mode,
		const TranslationTableRule **rules, int *rulesLen);

int EXPORT_CALL
_lou_backTranslate(const char *tableList, const char *displayTableList,
		const widechar *inbuf, int *inlen, widechar *outbuf, int *outlen,
		formtype *typeform, char *spacing, int *outputPos, int *inputPos, int *cursorPos,
		int mode, const TranslationTableRule **rules, int *rulesLen);

void EXPORT_CALL
_lou_resetPassVariables(void);

int EXPORT_CALL
_lou_handlePassVariableTest(const widechar *instructions, int *IC, int *itsTrue);

int EXPORT_CALL
_lou_handlePassVariableAction(const widechar *instructions, int *IC);

int EXPORT_CALL
_lou_pattern_compile(const widechar *input, const int input_max, widechar *expr_data,
		const int expr_max, TranslationTableHeader *table, const FileInfo *nested);

void EXPORT_CALL
_lou_pattern_reverse(widechar *expr_data);

int EXPORT_CALL
_lou_pattern_check(const widechar *input, const int input_start, const int input_minmax,
		const int input_dir, const widechar *expr_data,
		const TranslationTableHeader *table);

/**
 * Read a line of widechar's from an input file
 */
int EXPORT_CALL
_lou_getALine(FileInfo *info);

#ifdef DEBUG
/* Can be inserted in code to be used as a breakpoint in gdb */
void EXPORT_CALL
_lou_debugHook(void);
#endif

/**
 * Print an out-of-memory message and exit
 */
void EXPORT_CALL
_lou_outOfMemory(void);

/**
 * Helper for logging a widechar buffer
 */
void EXPORT_CALL
_lou_logWidecharBuf(logLevels level, const char *msg, const widechar *wbuf, int wlen);

void EXPORT_CALL
_lou_logMessage(logLevels level, const char *format, ...);

void EXPORT_CALL
_lou_freeTableIndex(void);

extern int translation_direction;

/**
 * Return 1 if given translation mode is valid. Return 0 otherwise.
 */
int EXPORT_CALL
_lou_isValidMode(int mode);

/**
 * Return the default braille representation for a character.
 */
widechar EXPORT_CALL
_lou_charToFallbackDots(widechar c);

static inline int
isASCII(widechar c) {
	return (c >= 0X20) && (c < 0X7F);
}

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* __LOUIS_H_ */
