Merge "AArch64: Enable build on 64-bit AArch64 platform"

22 files changed, 258 insertions, 158 deletions

diff --git a/make/asr/Makefile.config b/make/asr/Makefile.config
index e62623f..581fa77 100644
--- a/make/asr/Makefile.config
+++ b/make/asr/Makefile.config
@@ -27,6 +27,10 @@ ifeq ($(TARGET_ARCH),mips)
   ASR_CPU         = MIPS
   ASR_TARGET_CPU  = MIPS
 endif
+ifeq ($(TARGET_ARCH),aarch64)
+  ASR_CPU         = AARCH64
+  ASR_TARGET_CPU  = AARCH64
+endif
 ifeq ($(ASR_TARGET_CPU),)
   $(error Unsupported TARGET_ARCH for ASR)
 endif
diff --git a/make/asr/Makefile.defs b/make/asr/Makefile.defs
index 7a18810..70d97d9 100644
--- a/make/asr/Makefile.defs
+++ b/make/asr/Makefile.defs
@@ -49,6 +49,7 @@
 #	$(ASR_CPU_SPARC)	Value associated with $(ASR_CPU_CHARS) = SP.
 #	$(ASR_CPU_ARM)		Value associated with $(ASR_CPU_CHARS) = AR.
 #	$(ASR_CPU_STRONGARM)Value associated with $(ASR_CPU_CHARS) = SA.
+#	$(ASR_CPU_AARCH64)  Value associated with $(ASR_CPU_CHARS) = AA.
 #	$(ASR_CPU_TMS320X)	Value associated with $(ASR_CPU_CHARS) = TI.
 #	$(ASR_CPU_SH3)		Value associated with $(ASR_CPU_CHARS) = HI.
 #	$(ASR_CPU_SH4)		Value associated with $(ASR_CPU_CHARS) = HI.
@@ -129,6 +130,7 @@ ASR_CPU_STRONGARM = 128
 ASR_CPU_TMS320X = 256
 ASR_CPU_SH3 = 512
 ASR_CPU_SH4 = 1024
+ASR_CPU_AARCH64 = 2048
 
 # Used only by TFLAGS.MAK.
 
@@ -422,6 +424,11 @@ ASR_CPU_TYPE = $(ASR_CPU_STRONGARM)
 ASR_CPU_CHARS = sa
 
 else
+ifeq ("$(ASR_CPU)","AARCH64")
+ASR_CPU_TYPE = $(ASR_CPU_AARCH64)
+ASR_CPU_CHARS = aa
+
+else
 ifeq ("$(ASR_CPU)","TMS320X")
 ASR_CPU_TYPE = $(ASR_CPU_TMS320X)
 ASR_CPU_CHARS = ti
@@ -488,6 +495,7 @@ endif
 endif
 endif
 endif
+endif
 
 ################################## HOST_CPU #################################
 
@@ -523,6 +531,10 @@ ifeq ("$(ASR_HOST_CPU)","STRONGARM")
 ASR_HOST_CPU_TYPE = $(ASR_CPU_STRONGARM)
 
 else
+ifeq ("$(ASR_HOST_CPU)","AARCH64")
+ASR_HOST_CPU_TYPE = $(ASR_CPU_AARCH64)
+
+else
 ifeq ("$(ASR_HOST_CPU)","TMS320X")
 ASR_HOST_CPU_TYPE = $(ASR_CPU_TMS320X)
 
@@ -584,6 +596,7 @@ endif
 endif
 endif
 endif
+endif
 
 ################################## TARGET_CPU #################################
 
@@ -619,6 +632,10 @@ ifeq ("$(ASR_TARGET_CPU)","STRONGARM")
 ASR_TARGET_CPU_TYPE = $(ASR_CPU_STRONGARM)
 
 else
+ifeq ("$(ASR_TARGET_CPU)","AARCH64")
+ASR_TARGET_CPU_TYPE = $(ASR_CPU_AARCH64)
+
+else
 ifeq ("$(ASR_TARGET_CPU)","TMS320X")
 ASR_TARGET_CPU_TYPE = $(ASR_CPU_TMS320X)
 
@@ -680,6 +697,7 @@ endif
 endif
 endif
 endif
+endif
 
 
 ############################### COMPILER ###############################
@@ -849,6 +867,7 @@ ASR_GLOBAL_DEFINES = \
 	-DCPU_SPARC=$(ASR_CPU_SPARC) \
 	-DCPU_ARM=$(ASR_CPU_ARM) \
 	-DCPU_STRONGARM=$(ASR_CPU_STRONGARM) \
+	-DCPU_AARCH64=$(ASR_CPU_AARCH64) \
 	-DCPU_TMS320X=$(ASR_CPU_TMS320X) \
 	-DCPU_SH3=$(ASR_CPU_SH3) \
 	-DCPU_SH4=$(ASR_CPU_SH4) \
diff --git a/portable/include/LCHAR.h b/portable/include/LCHAR.h
index 2bea16a..0ff0230 100644
--- a/portable/include/LCHAR.h
+++ b/portable/include/LCHAR.h
@@ -84,6 +84,16 @@ PORTABLE_API ESR_ReturnCode lstrtoi(const LCHAR* text, int* result, int base);
 PORTABLE_API ESR_ReturnCode lstrtoui(const LCHAR* text, unsigned int* result, int base);
 
 /**
+ * Converts string to size_t.
+ *
+ * @param text String to parse
+ * @param result [out] Resulting value
+ * @param base Number base to use
+ * @return ESR_INVALID_ARGUMENT is text is null or does not represent a number
+ */
+PORTABLE_API ESR_ReturnCode lstrtosize_t(const LCHAR* text, size_t* result, int base);
+
+/**
  * Converts string to float.
  *
  * @param text String to parse
diff --git a/portable/include/ptypes.h b/portable/include/ptypes.h
index 40352c0..a761b80 100644
--- a/portable/include/ptypes.h
+++ b/portable/include/ptypes.h
@@ -457,6 +457,11 @@ typedef wint_t LINT;
  */
 #define LOG_10_2 (0.30102999566398)
 
+/**
+ * Maximum number of characters used to represent a pointer as a string in
+ * hex.  The +2 is for 0x that would preceed the address.
+ */
+#define MAX_POINTER_CHARS ((size_t) ((CHAR_BIT * sizeof(void*) * 2))+2)
 
 /**
  * Maximum number of digits used to represent an unsigned int as a string in
diff --git a/portable/src/LCHAR.c b/portable/src/LCHAR.c
index d17e0e8..d51fc3a 100644
--- a/portable/src/LCHAR.c
+++ b/portable/src/LCHAR.c
@@ -102,6 +102,18 @@ ESR_ReturnCode lstrtoui(const LCHAR* text, unsigned int* result, int base)
   return ESR_SUCCESS;
 }
 
+ESR_ReturnCode lstrtosize_t(const LCHAR* text, size_t* result, int base)
+{
+  LCHAR* endPtr;
+
+  if (result == NULL)
+    return ESR_INVALID_ARGUMENT;
+  *result = (size_t) LSTRTOUL(text, &endPtr, base);
+  if (endPtr == text || (!LISSPACE(*endPtr) && *endPtr != L('\0')))
+    return ESR_INVALID_ARGUMENT;
+  return ESR_SUCCESS;
+}
+
 ESR_ReturnCode lstrtof(const LCHAR* text, float* result)
 {
   LCHAR* endPtr;
diff --git a/seti/sltsEngine/src/run_seq_lts.c b/seti/sltsEngine/src/run_seq_lts.c
index 1d9fb05..f1dcb08 100644
--- a/seti/sltsEngine/src/run_seq_lts.c
+++ b/seti/sltsEngine/src/run_seq_lts.c
@@ -155,7 +155,7 @@ void* my_PHashTableCreate_FromStrings( const char* strings[], int num_strings,
     /* formerly the code used linear lookup, so let's avoid dups to match up */
     rc = PHashTableGetValue( table, strings[i], (void**)&old);
     if(rc != ESR_SUCCESS) {
-      rc = PHashTablePutValue( table, strings[i], (const void *)i, NULL );
+      rc = PHashTablePutValue( table, strings[i], (const void *)(intptr_t) i, NULL );
     }
   }
   return table;
diff --git a/shared/src/SessionTypeImpl.c b/shared/src/SessionTypeImpl.c
index 9766785..94035b4 100644
--- a/shared/src/SessionTypeImpl.c
+++ b/shared/src/SessionTypeImpl.c
@@ -757,7 +757,7 @@ ESR_ReturnCode ESR_SessionTypeConvertToSize_tImpl(ESR_SessionType* self,
     rc = ESR_OUT_OF_MEMORY;
     goto CLEANUP;
   }
-  CHKLOG(rc, lstrtoui(value, (unsigned int *)newValue, 10));
+  CHKLOG(rc, lstrtosize_t(value, newValue, 10));
   CHKLOG(rc, self->setProperty(self, key, newValue, TYPES_SIZE_T));
   FREE(value);
   return ESR_SUCCESS;
@@ -1097,7 +1097,7 @@ static ESR_ReturnCode addParMapping(ESR_SessionType* self,
         CHKLOG(rc, self->setInt(self, key, iValue));
         break;
       case TYPES_UINT16_T:
-        CHKLOG(rc, lstrtoui(value, (unsigned int *)&size_tValue, 10));
+        CHKLOG(rc, lstrtosize_t(value, &size_tValue, 10));
         passert(size_tValue >= UINT16_TMIN && size_tValue <= UINT16_TMAX);
         CHKLOG(rc, self->contains(self, key, &exists));
         if (exists)
@@ -1105,7 +1105,7 @@ static ESR_ReturnCode addParMapping(ESR_SessionType* self,
         CHKLOG(rc, self->setUint16_t(self, key, (asr_uint16_t) size_tValue));
         break;
       case TYPES_SIZE_T:
-        CHKLOG(rc, lstrtoui(value, (unsigned int *)&size_tValue, 10));
+        CHKLOG(rc, lstrtosize_t(value, &size_tValue, 10));
         CHKLOG(rc, self->contains(self, key, &exists));
         if (exists)
           CHKLOG(rc, self->removeAndFreeProperty(self, key));
diff --git a/srec/EventLog/include/SR_EventLog.h b/srec/EventLog/include/SR_EventLog.h
index bfa1770..f0ac7ee 100644
--- a/srec/EventLog/include/SR_EventLog.h
+++ b/srec/EventLog/include/SR_EventLog.h
@@ -66,6 +66,13 @@
    log->tokenInt(log, tokenName, value) : ESR_SUCCESS ) \
 
 /**
+ * Log a pointer token using the basic logging level.
+ */
+#define SR_EventLogTokenPointer_BASIC(log, loglevel, tokenName, value)  \
+  ((loglevel & OSI_LOG_LEVEL_BASIC) ? \
+   log->tokenPointer(log, tokenName, value) : ESR_SUCCESS ) \
+
+/**
  * Log a uint16 token using the basic logging level.
  */
 #define SR_EventLogTokenUint16_t_BASIC(log, loglevel, tokenName, value)  \
@@ -158,6 +165,15 @@ typedef struct SR_EventLog_t
 	 * @param token Token name
 	 * @param value Token value
 	 */
+	ESR_ReturnCode(*tokenPointer)(struct SR_EventLog_t* self, const LCHAR* token, void* value);
+
+	/**
+	 * Logs an OSI log token.
+	 *
+	 * @param self SR_EventLog handle
+	 * @param token Token name
+	 * @param value Token value
+	 */
 	ESR_ReturnCode(*tokenUint16_t)(struct SR_EventLog_t* self, const LCHAR* token, asr_uint16_t value);
 
 	/**
@@ -281,6 +297,15 @@ SREC_EVENTLOG_API ESR_ReturnCode SR_EventLogTokenInt(SR_EventLog* self, const LC
  * @param token Token name
  * @param value Token value
  */
+SREC_EVENTLOG_API ESR_ReturnCode SR_EventLogTokenPointer(SR_EventLog* self, const LCHAR* token, void* value);
+
+/**
+ * Logs an OSI log token.
+ *
+ * @param self SR_EventLog handle
+ * @param token Token name
+ * @param value Token value
+ */
 SREC_EVENTLOG_API ESR_ReturnCode SR_EventLogTokenUint16_t(SR_EventLog* self, const LCHAR* token, asr_uint16_t value);
 
 /**
diff --git a/srec/EventLog/include/SR_EventLogImpl.h b/srec/EventLog/include/SR_EventLogImpl.h
index 00840e9..d3f7018 100644
--- a/srec/EventLog/include/SR_EventLogImpl.h
+++ b/srec/EventLog/include/SR_EventLogImpl.h
@@ -77,6 +77,8 @@ SREC_EVENTLOG_API ESR_ReturnCode SR_EventLog_Token(SR_EventLog* self, const LCHA
 
 SREC_EVENTLOG_API ESR_ReturnCode SR_EventLog_TokenInt(SR_EventLog* self, const LCHAR* token, int value);
 
+SREC_EVENTLOG_API ESR_ReturnCode SR_EventLog_TokenPointer(SR_EventLog* self, const LCHAR* token, void* value);
+
 SREC_EVENTLOG_API ESR_ReturnCode SR_EventLog_TokenUint16_t(SR_EventLog* self, const LCHAR* token, asr_uint16_t value);
 
 SREC_EVENTLOG_API ESR_ReturnCode SR_EventLog_TokenSize_t(SR_EventLog* self, const LCHAR* token, size_t value);
diff --git a/srec/EventLog/src/EventLog.c b/srec/EventLog/src/EventLog.c
index 6760132..db4b040 100644
--- a/srec/EventLog/src/EventLog.c
+++ b/srec/EventLog/src/EventLog.c
@@ -53,6 +53,16 @@ ESR_ReturnCode SR_EventLogTokenInt(SR_EventLog* self, const LCHAR* token, int va
   return self->tokenInt(self, token, value);
 }
 
+ESR_ReturnCode SR_EventLogTokenPointer(SR_EventLog* self, const LCHAR* token, void* value)
+{
+  if (self == NULL)
+  {
+    PLogError(L("ESR_INVALID_ARGUMENT"));
+    return ESR_INVALID_ARGUMENT;
+  }
+  return self->tokenPointer(self, token, value);
+}
+
 ESR_ReturnCode SR_EventLogTokenUint16_t(SR_EventLog* self, const LCHAR* token, asr_uint16_t value)
 {
   if (self == NULL)
diff --git a/srec/EventLog/src/EventLogImpl.c b/srec/EventLog/src/EventLogImpl.c
index 90c0d87..2c275de 100644
--- a/srec/EventLog/src/EventLogImpl.c
+++ b/srec/EventLog/src/EventLogImpl.c
@@ -190,6 +190,7 @@ ESR_ReturnCode SR_EventLogCreate(SR_EventLog** self)
   impl->Interface.event = &SR_EventLog_Event;
   impl->Interface.token = &SR_EventLog_Token;
   impl->Interface.tokenInt = &SR_EventLog_TokenInt;
+  impl->Interface.tokenPointer = &SR_EventLog_TokenPointer;
   impl->Interface.tokenUint16_t = &SR_EventLog_TokenUint16_t;
   impl->Interface.tokenSize_t = &SR_EventLog_TokenSize_t;
   impl->Interface.tokenBool = &SR_EventLog_TokenBool;
@@ -401,6 +402,17 @@ CLEANUP:
   return rc;
 }
 
+ESR_ReturnCode SR_EventLog_TokenPointer(SR_EventLog* self, const LCHAR* token, void* value)
+{
+  SR_EventLogImpl *impl = (SR_EventLogImpl *)self;
+  LCHAR alpha[MAX_POINTER_CHARS+1];
+
+  if (impl->logLevel == 0)
+    return ESR_SUCCESS;
+  sprintf(alpha, "%p", value);
+  return self->token(self, token, alpha);
+}
+
 ESR_ReturnCode SR_EventLog_TokenUint16_t(SR_EventLog* self, const LCHAR* token, asr_uint16_t value)
 {
   SR_EventLogImpl *impl = (SR_EventLogImpl *)self;
diff --git a/srec/Grammar/src/SR_GrammarImpl.c b/srec/Grammar/src/SR_GrammarImpl.c
index 0406d66..961a393 100644
--- a/srec/Grammar/src/SR_GrammarImpl.c
+++ b/srec/Grammar/src/SR_GrammarImpl.c
@@ -228,7 +228,7 @@ ESR_ReturnCode SR_Grammar_AddWordToSlot(SR_Grammar* self, const LCHAR* slot, con
    */
   if (impl->eventLog != NULL)
   {
-    CHKLOG(logrc, SR_EventLogTokenInt_BASIC(impl->eventLog, impl->logLevel, L("igrm"), (int)impl));
+    CHKLOG(logrc, SR_EventLogTokenPointer_BASIC(impl->eventLog, impl->logLevel, L("igrm"), impl));
     CHKLOG(logrc, SR_EventLogToken_BASIC(impl->eventLog, impl->logLevel, L("SLOT"), slot));
     CHKLOG(logrc, SR_EventLogToken_BASIC(impl->eventLog, impl->logLevel, L("WORD"), word));
     if (input_pronunciation)
@@ -313,7 +313,7 @@ ESR_ReturnCode SR_Grammar_ResetAllSlots(SR_Grammar* self)
   
   if (impl->eventLog != NULL)
   {
-    CHKLOG(rc, SR_EventLogTokenInt_BASIC(impl->eventLog, impl->logLevel, L("igrm"), (int)impl));
+    CHKLOG(rc, SR_EventLogTokenPointer_BASIC(impl->eventLog, impl->logLevel, L("igrm"), impl));
     if (rc == ESR_SUCCESS)
       CHKLOG(logrc, SR_EventLogToken_BASIC(impl->eventLog, impl->logLevel, L("RSLT"), L("ok")));
     else
@@ -445,7 +445,7 @@ ESR_ReturnCode SR_GrammarLoad(const LCHAR* grammar, SR_Grammar** self)
   *self = Interface;
   if (impl->eventLog)
   {
-    CHKLOG(rc, SR_EventLogTokenInt_BASIC(impl->eventLog, impl->logLevel, L("igrm"), (int)impl));
+    CHKLOG(rc, SR_EventLogTokenPointer_BASIC(impl->eventLog, impl->logLevel, L("igrm"), impl));
     CHKLOG(rc, SR_EventLogToken_BASIC(impl->eventLog, impl->logLevel, L("name"), filename));
     CHKLOG(rc, SR_EventLogEvent_BASIC(impl->eventLog, impl->logLevel, L("ESRldgrm")));
   }
@@ -583,7 +583,7 @@ ESR_ReturnCode SR_Grammar_Destroy(SR_Grammar* self)
   
   if (impl->eventLog)
   {
-    CHKLOG(rc, SR_EventLogTokenInt_BASIC(impl->eventLog, impl->logLevel, L("igrm"), (int)impl));
+    CHKLOG(rc, SR_EventLogTokenPointer_BASIC(impl->eventLog, impl->logLevel, L("igrm"), impl));
     CHKLOG(rc, SR_EventLogEvent_BASIC(impl->eventLog, impl->logLevel, L("ESRklgrm")));
   }
   
diff --git a/srec/Nametag/src/NametagsImpl.c b/srec/Nametag/src/NametagsImpl.c
index d3d4943..38699bd 100644
--- a/srec/Nametag/src/NametagsImpl.c
+++ b/srec/Nametag/src/NametagsImpl.c
@@ -60,7 +60,7 @@ ESR_ReturnCode SR_NametagsCreate(SR_Nametags** self)
   CHKLOG(rc, ESR_SessionGetSize_t(L("SREC.Recognizer.osi_log_level"), &impl->logLevel));
   if (impl->logLevel > 0)
     CHKLOG(rc, ESR_SessionGetProperty(L("eventlog"), (void **)&impl->eventLog, TYPES_SR_EVENTLOG));
-  CHKLOG(rc, SR_EventLogTokenInt_BASIC(impl->eventLog, impl->logLevel, L("pointer"), (int) self));
+  CHKLOG(rc, SR_EventLogTokenPointer_BASIC(impl->eventLog, impl->logLevel, L("pointer"), self));
   CHKLOG(rc, SR_EventLogEvent_BASIC(impl->eventLog, impl->logLevel, L("SR_NametagsCreate")));
   *self = (SR_Nametags*) impl;
   return ESR_SUCCESS;
@@ -400,7 +400,7 @@ ESR_ReturnCode SR_NametagsDestroyImpl(SR_Nametags* self)
     list->destroy(list);
     impl->value = NULL;
   }
-  CHKLOG(rc, SR_EventLogTokenInt_BASIC(impl->eventLog, impl->logLevel, L("pointer"), (int) self));
+  CHKLOG(rc, SR_EventLogTokenPointer_BASIC(impl->eventLog, impl->logLevel, L("pointer"), self));
   CHKLOG(rc, SR_EventLogEvent_BASIC(impl->eventLog, impl->logLevel, L("SR_NametagsDestroy")));
   impl->eventLog = NULL;
   FREE(self);
diff --git a/srec/Recognizer/src/RecognizerImpl.c b/srec/Recognizer/src/RecognizerImpl.c
index 4edf2dc..899b3cd 100644
--- a/srec/Recognizer/src/RecognizerImpl.c
+++ b/srec/Recognizer/src/RecognizerImpl.c
@@ -952,7 +952,7 @@ ESR_ReturnCode beginRecognizing(SR_RecognizerImpl* impl)
   CHKLOG(rc, HashMapGetSize(impl->grammars, &grammarSize));
   for (i = 0; i < grammarSize; ++i)
   {
-    psprintf(tok, L("GURI%d"), i);
+    psprintf(tok, L("GURI%zu"), i);
     /* use the key as the grammar URI */
     CHKLOG(rc, HashMapGetKeyAtIndex(impl->grammars, i, &val));
     CHKLOG(rc, SR_EventLogToken_BASIC(impl->eventLog, impl->osi_log_level, tok, val));
@@ -1613,7 +1613,7 @@ CLEANUP:
   {
     if (failure_reason)
     {
-      SR_EventLogTokenInt(impl->eventLog, L("igrm"), (int) grammar);
+      SR_EventLogTokenPointer(impl->eventLog, L("igrm"), grammar);
       SR_EventLogToken(impl->eventLog, L("rule"), ruleName);
       SR_EventLogToken(impl->eventLog, L("rslt"), "fail");
       SR_EventLogToken(impl->eventLog, L("reason"), failure_reason);
@@ -1621,7 +1621,7 @@ CLEANUP:
     }
     else
     {
-      SR_EventLogTokenInt(impl->eventLog, L("igrm"), (int) grammar);
+      SR_EventLogTokenPointer(impl->eventLog, L("igrm"), grammar);
       SR_EventLogToken(impl->eventLog, L("rule"), ruleName);
       SR_EventLogToken(impl->eventLog, L("rslt"), "ok");
       SR_EventLogEvent(impl->eventLog, L("ESRacGrm"));
@@ -1755,7 +1755,7 @@ ESR_ReturnCode SR_RecognizerPutAudioImpl(SR_Recognizer* self, asr_int16_t* buffe
   if (rcBufWrite < 0)
   {
     rc = ESR_INVALID_STATE;
-    PLogError(L("%s: error writing to buffer (buffer=%d, available=%u)"), ESR_rc2str(rc), (int) impl->buffer, CircularBufferGetAvailable(impl->buffer));
+    PLogError(L("%s: error writing to buffer (buffer=%p, available=%u)"), ESR_rc2str(rc), impl->buffer, CircularBufferGetAvailable(impl->buffer));
     goto CLEANUP;
   }
 
@@ -1926,12 +1926,12 @@ ESR_ReturnCode filter_CA_FullResultLabel(const LCHAR* label, LCHAR *filtered_lab
 
   /* set the eos signal indicated by the end pointed data */
   if (eosBuf[0] != 0)
-    CHKLOG(rc, lstrtoui(eosBuf, eoss, 10));
+    CHKLOG(rc, lstrtosize_t(eosBuf, eoss, 10));
   else
     eoss = 0;
 
   if (bosBuf[0] != 0)
-    CHKLOG(rc, lstrtoui(bosBuf, boss, 10));
+    CHKLOG(rc, lstrtosize_t(bosBuf, boss, 10));
   else
     boss = 0;
 
@@ -2270,7 +2270,7 @@ ESR_ReturnCode SR_RecognizerCreateResultImpl(SR_Recognizer* self, SR_RecognizerS
     if (semanticResultsSize > 0)
       {
         /* OSI log the grammar(s) that was used in recognizing */
-        psprintf(tok, L("GURI%d"), grammarIndex_for_iBest);
+        psprintf(tok, L("GURI%zd"), grammarIndex_for_iBest);
         CHKLOG(rc, SR_EventLogToken_BASIC(impl->eventLog, impl->osi_log_level, L("GRMR"), tok));
       }
 #else
@@ -3897,7 +3897,7 @@ ESR_ReturnCode WaveformBuffer_ParseEndPointedResultAndTrim(WaveformBuffer* wavef
 
   p = LSTRSTR( end_pointed_result, PREFIX_WORD);
   if(p) p+=PREFIX_WORD_LEN; while(p && *p == '@') p++;
-  rc = p ? lstrtoui(p, &bos_frame, 10) : ESR_INVALID_ARGUMENT;
+  rc = p ? lstrtosize_t(p, &bos_frame, 10) : ESR_INVALID_ARGUMENT;
   if (rc == ESR_INVALID_ARGUMENT)
   {
     PLogError(L("%s: extracting bos from text=%s"), ESR_rc2str(rc), end_pointed_result);
@@ -3908,7 +3908,7 @@ ESR_ReturnCode WaveformBuffer_ParseEndPointedResultAndTrim(WaveformBuffer* wavef
 
   p = LSTRSTR( end_pointed_result, SUFFIX_WORD);
   while(p && p>end_pointed_result && p[-1]!='@') --p;
-  rc = p ? lstrtoui(p, &eos_frame, 10) : ESR_INVALID_ARGUMENT;
+  rc = p ? lstrtosize_t(p, &eos_frame, 10) : ESR_INVALID_ARGUMENT;
   if (rc == ESR_INVALID_ARGUMENT)
   {
     PLogError(L("%s: extracting eos from text=%s"), ESR_rc2str(rc), end_pointed_result);
diff --git a/srec/cfront/sh_down.h b/srec/cfront/sh_down.h
index 3d73cb4..ec38459 100644
--- a/srec/cfront/sh_down.h
+++ b/srec/cfront/sh_down.h
@@ -79,13 +79,13 @@ static PINLINE int fixed_point_convert(float xx, int shift)
   ASSERT(shift >= 0);
   scaled_val = xx * (0x01 << shift);
   if (scaled_val >= 0)
-    if (scaled_val > LONG_MAX)
-      return (LONG_MAX);
+    if (scaled_val > INT_MAX)
+      return (INT_MAX);
     else
       return ((int)(scaled_val + 0.5));
   else
-    if (scaled_val < -LONG_MAX)
-      return (-LONG_MAX);
+    if (scaled_val < -INT_MAX)
+      return (-INT_MAX);
     else
       return ((int)(scaled_val - 0.5));
 }
diff --git a/srec/clib/swicms.c b/srec/clib/swicms.c
index 6958789..a23236f 100644
--- a/srec/clib/swicms.c
+++ b/srec/clib/swicms.c
@@ -28,7 +28,7 @@
 #include "IntArrayList.h"
 #include "portable.h"
 
-#define printf_vector(HEAD, FMT, PTR, NN) { int i; LCHAR buffer[256]; sprintf(buffer, HEAD); sprintf(buffer + LSTRLEN(buffer), " %x", (int)PTR); for (i=0; i<(NN); ++i) sprintf(buffer + LSTRLEN(buffer), FMT, PTR[i]); PLogMessage(buffer); }
+#define printf_vector(HEAD, FMT, PTR, NN) { int i; LCHAR buffer[256]; sprintf(buffer, HEAD); sprintf(buffer + LSTRLEN(buffer), " %p", (void *)PTR); for (i=0; i<(NN); ++i) sprintf(buffer + LSTRLEN(buffer), FMT, PTR[i]); PLogMessage(buffer); }
 
 /* Cross-utterance CMN calculation:
    We try to normalize the speech frames before they get to the recognizer.
diff --git a/srec/crec/astar_pphash.c b/srec/crec/astar_pphash.c
index 22e838b..9720c40 100644
--- a/srec/crec/astar_pphash.c
+++ b/srec/crec/astar_pphash.c
@@ -63,7 +63,7 @@ int compare_parp(partial_path* parp1, partial_path* parp2, srec* rec)
       parp1 = parp1->next;
       parp2 = parp2->next;
     }
-    diff = (int)parp1->next - (int)parp2->next;
+    diff = (intptr_t)parp1->next - (intptr_t)parp2->next;
   }
 CPE:
   if (diff)
diff --git a/srec/crec/srec_context.c b/srec/crec/srec_context.c
index 1de8f35..49fae74 100644
--- a/srec/crec/srec_context.c
+++ b/srec/crec/srec_context.c
@@ -41,6 +41,7 @@ static const char *rcsid = 0 ? (const char *) &rcsid :
 "$Id: srec_context.c,v 1.84.4.54 2008/05/15 20:06:39 dahan Exp $";
 #endif
 
+#include <stdint.h>
 
 /* these are constants for now, we need to figure out how to make
    this more flexible, possible ideas are:
@@ -468,7 +469,7 @@ wordID wordmap_find_index(wordmap* wmap, const char* word)
     rc = PHashTableGetValue(wmap->wordIDForWord, word, (void**)&wdID_void);
 
     if (rc == ESR_SUCCESS)
-      return (wordID)(int)wdID_void;
+      return (wordID)(uintptr_t)wdID_void;
   }
   else
   {
@@ -515,7 +516,7 @@ wordID wordmap_find_index_in_rule(wordmap* wmap, const char* word, wordID rule)
   word_dot_rule[len++] = 0;
   rc = PHashTableGetValue(wmap->wordIDForWord, word_dot_rule, (void**)&wdID_void);
   if (rc == ESR_SUCCESS)
-    return (wordID)(int)(wdID_void);
+    return (wordID)(uintptr_t)(wdID_void);
   return MAXwordID;
 }
 
@@ -600,7 +601,7 @@ static ESR_ReturnCode wordmap_populate ( wordmap *word_map, wordID num_words )
       while ( ( wdID < num_words ) && ( populate_status == ESR_SUCCESS ) )
 	{
 	  populate_status = PHashTablePutValue ( word_map->wordIDForWord, word_map->words[wdID],
-						 (const void *)(int)wdID, NULL );
+						 (const void *)(uintptr_t)wdID, NULL );
 	  if ( populate_status == ESR_SUCCESS )
 	    wdID++;
 	  else {
@@ -678,7 +679,7 @@ wordID wordmap_add_word(wordmap* wmap, const char* word)
   if (wmap->next_chars + len >= wmap->chars + wmap->max_chars)
   {
 #if defined(FST_GROW_FACTOR)
-     int i,tmp_max_chars= wmap->max_chars * FST_GROW_FACTOR;
+      uintptr_t i,tmp_max_chars= wmap->max_chars * FST_GROW_FACTOR;
 	 char* old_wmap__chars = wmap->chars;
       if(tmp_max_chars - wmap->max_chars < FST_GROW_MINCHARS)
 	tmp_max_chars +=FST_GROW_MINCHARS;
@@ -756,7 +757,7 @@ wordID wordmap_add_word(wordmap* wmap, const char* word)
     if (wmap->wordIDForWord)
     {
        ESR_ReturnCode rc = PHashTablePutValue ( wmap->wordIDForWord, wmap->words[wdID],
-                      (const void *)(int)wdID, NULL );
+                      (const void *)(uintptr_t)wdID, NULL );
     if ( rc != ESR_SUCCESS )
       goto CLEANUP;
     }
@@ -809,7 +810,7 @@ wordID wordmap_add_word_in_rule(wordmap* wmap, const char* word, wordID rule)
 	  // adjust hashtable ----- add in rulewordmap_add_word_in_rule ----
 	  if (wmap->wordIDForWord) {
 	    ESR_ReturnCode rc = PHashTablePutValue ( wmap->wordIDForWord, wmap->words[i],
-						     (void*)(int)(i), NULL );
+						     (void*)(uintptr_t)(i), NULL );
 	    if ( rc != ESR_SUCCESS )
 	      goto CLEANUP;
 	  }
@@ -863,7 +864,7 @@ wordID wordmap_add_word_in_rule(wordmap* wmap, const char* word, wordID rule)
     if (wmap->wordIDForWord)
       {
         ESR_ReturnCode rc = PHashTablePutValue ( wmap->wordIDForWord, wmap->words[wdID],
-						 (void*)(int)(wdID), NULL );
+						 (void*)(uintptr_t)(wdID), NULL );
 	if ( rc != ESR_SUCCESS )
 	  goto CLEANUP;
       }
@@ -2834,7 +2835,7 @@ ESR_ReturnCode deserializeWordMapV2(wordmap **pwordmap, PFile* fp)
 
 
   p = awordmap->chars;
-  ASSERT((int)p % 2 == 0);
+  ASSERT((uintptr_t)p % 2 == 0);
   nfields = 0;
   if (nfields < awordmap->num_words)
     awordmap->words[nfields++] = p;
@@ -2844,7 +2845,7 @@ ESR_ReturnCode deserializeWordMapV2(wordmap **pwordmap, PFile* fp)
     {
       if (nfields == awordmap->num_words) // was num_base_words
         break;
-      if (((int)p) % 2 == 0) p++; /* so that words begin on even byte bound */
+      if (((uintptr_t)p) % 2 == 0) p++; /* so that words begin on even byte bound */
       awordmap->words[nfields++] = p + 1;
     }
   }
diff --git a/srec/test/SRecTest/src/SRecTest.c b/srec/test/SRecTest/src/SRecTest.c
index 072a650..27dd2a8 100644
--- a/srec/test/SRecTest/src/SRecTest.c
+++ b/srec/test/SRecTest/src/SRecTest.c
@@ -142,8 +142,8 @@ typedef struct ApplicationData_t
     const asr_int16_t                 *raw_waveform;      /*Points to raw waveform returned from voice enrollment */
     size_t                      raw_waveform_size;  /* Size of above wave_form */
     asr_int16_t                 audio_buffer [MAX_AUDIO_BUFFER_SIZE];
-    unsigned int                audio_buffer_requested_size;
-    unsigned int                num_samples_read;
+    size_t                      audio_buffer_requested_size;
+    size_t                      num_samples_read;
     LCHAR                       raw_waveform_filename [P_PATH_MAX];     /* Name of file of saved waveform data. */
     PFile                       *raw_waveform_file;     /* Pointer to file of saved waveform data. */
     LCHAR                       transcription [MAX_LINE_LENGTH];
@@ -1217,7 +1217,7 @@ int srec_test_get_size_t_parameter ( ApplicationData *data, LCHAR *command_text
 
         if ( esr_status == ESR_SUCCESS )
             {
-            printf ( "Get Parameter  :  %s  :  %u\n", key, value );
+            printf ( "Get Parameter  :  %s  :  %zu\n", key, value );
         }
     else
             {
diff --git a/srec/test/SRecTestAudio/src/SRecTestAudio.c b/srec/test/SRecTestAudio/src/SRecTestAudio.c
index 30633b8..0b133ac 100644
--- a/srec/test/SRecTestAudio/src/SRecTestAudio.c
+++ b/srec/test/SRecTestAudio/src/SRecTestAudio.c
@@ -141,8 +141,8 @@ typedef struct ApplicationData_t
     const asr_int16_t                 *raw_waveform;  /*Points to raw waveform returned from voice enrollment */
     size_t                      raw_waveform_size;  /* Size of above wave_form */
     asr_int16_t                 audio_buffer [MAX_AUDIO_BUFFER_SIZE];
-    unsigned int                audio_buffer_requested_size;
-    unsigned int                num_samples_read;
+    size_t                      audio_buffer_requested_size;
+    size_t                      num_samples_read;
     LCHAR                       raw_waveform_filename [P_PATH_MAX];     /* Name of file of saved waveform data. */
     PFile                       *raw_waveform_file;     /* Pointer to file of saved waveform data. */
     LCHAR                       transcription [MAX_LINE_LENGTH];
diff --git a/srec_jni/android_speech_srec_MicrophoneInputStream.cpp b/srec_jni/android_speech_srec_MicrophoneInputStream.cpp
index 998f2d4..529b317 100644
--- a/srec_jni/android_speech_srec_MicrophoneInputStream.cpp
+++ b/srec_jni/android_speech_srec_MicrophoneInputStream.cpp
@@ -65,7 +65,7 @@ private:
     const sp<AudioRecord> mAudioRecord;
 };
 
-static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_AudioRecordNew
+static JNIEXPORT jlong JNICALL Java_android_speech_srec_Recognizer_AudioRecordNew
         (JNIEnv *env, jclass clazz, jint sampleRate, jint fifoFrames) {
 
     AudioRecordWrapper *ar = new AudioRecordWrapper(new AudioRecord(
@@ -78,16 +78,16 @@ static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_AudioRecordNew
         ar = NULL;
         ALOGE("initCheck error %d ", s);
     }
-    return (int)ar;
+    return (jlong)ar;
 }
 
-static JNIEXPORT int JNICALL Java_android_speech_srec_Recognizer_AudioRecordStart
-        (JNIEnv *env, jclass clazz, jint audioRecord) {
-    return (int)(((AudioRecordWrapper*)audioRecord)->get()->start());
+static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_AudioRecordStart
+        (JNIEnv *env, jclass clazz, jlong audioRecord) {
+    return (jint)(((AudioRecordWrapper*)audioRecord)->get()->start());
 }
 
 static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_AudioRecordRead
-        (JNIEnv *env, jclass clazz, jint audioRecord, jbyteArray array, jint offset, jint length) {
+        (JNIEnv *env, jclass clazz, jlong audioRecord, jbyteArray array, jint offset, jint length) {
     jbyte buffer[4096];
     if (length > (int)sizeof(buffer)) length = sizeof(buffer);
     length = ((AudioRecordWrapper*)audioRecord)->get()->read(buffer, length);
@@ -100,12 +100,12 @@ static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_AudioRecordRea
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_AudioRecordStop
-        (JNIEnv *env, jclass clazz, jint audioRecord) {
+        (JNIEnv *env, jclass clazz, jlong audioRecord) {
     ((AudioRecordWrapper*)audioRecord)->get()->stop();
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_AudioRecordDelete
-        (JNIEnv *env, jclass clazz, jint audioRecord) {
+        (JNIEnv *env, jclass clazz, jlong audioRecord) {
     delete (AudioRecordWrapper*)audioRecord;
 }
 
@@ -115,11 +115,11 @@ static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_AudioRecordDel
  */
 static JNINativeMethod gMethods[] = {
     /* name, signature, funcPtr */
-    {"AudioRecordNew",    "(II)I",    (void*)Java_android_speech_srec_Recognizer_AudioRecordNew},
-    {"AudioRecordStart",  "(I)I",     (void*)Java_android_speech_srec_Recognizer_AudioRecordStart},
-    {"AudioRecordRead",   "(I[BII)I", (void*)Java_android_speech_srec_Recognizer_AudioRecordRead},
-    {"AudioRecordStop",   "(I)V",     (void*)Java_android_speech_srec_Recognizer_AudioRecordStop},
-    {"AudioRecordDelete", "(I)V",     (void*)Java_android_speech_srec_Recognizer_AudioRecordDelete},
+    {"AudioRecordNew",    "(II)J",    (void*)Java_android_speech_srec_Recognizer_AudioRecordNew},
+    {"AudioRecordStart",  "(J)I",     (void*)Java_android_speech_srec_Recognizer_AudioRecordStart},
+    {"AudioRecordRead",   "(J[BII)I", (void*)Java_android_speech_srec_Recognizer_AudioRecordRead},
+    {"AudioRecordStop",   "(J)V",     (void*)Java_android_speech_srec_Recognizer_AudioRecordStop},
+    {"AudioRecordDelete", "(J)V",     (void*)Java_android_speech_srec_Recognizer_AudioRecordDelete},
 };
 
 /*
diff --git a/srec_jni/android_speech_srec_Recognizer.cpp b/srec_jni/android_speech_srec_Recognizer.cpp
index 5662714..33431a4 100644
--- a/srec_jni/android_speech_srec_Recognizer.cpp
+++ b/srec_jni/android_speech_srec_Recognizer.cpp
@@ -109,119 +109,119 @@ static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1SessionDes
 //////////////////////////////////////////////////////////////////////////
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerStart
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     checkEsrError(env, SR_RecognizerStart((SR_Recognizer*)recognizer));
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerStop
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     checkEsrError(env, SR_RecognizerStop((SR_Recognizer*)recognizer));
 }
 
-static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerCreate
+static JNIEXPORT jlong JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerCreate
         (JNIEnv *env, jclass clazz) {
     SR_Recognizer* recognizer = NULL;
     // TODO: do we need to clean up the recognizer if this fails?
     checkEsrError(env, SR_RecognizerCreate(&recognizer));
-    return (jint)recognizer;
+    return (jlong)recognizer;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerDestroy
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     checkEsrError(env, SR_RecognizerDestroy((SR_Recognizer*)recognizer));
     return;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetup
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     checkEsrError(env, SR_RecognizerSetup((SR_Recognizer*)recognizer));
     return;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerUnsetup
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     checkEsrError(env, SR_RecognizerUnsetup((SR_Recognizer*)recognizer));
     return;
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSetup
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerIsSetup((SR_Recognizer*)recognizer, &rtn));
     return rtn;
 }
 
 static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerGetParameter
-  (JNIEnv *env, jclass clazz, jint recognizer, jstring key) {
+  (JNIEnv *env, jclass clazz, jlong recognizer, jstring key) {
     unimplemented(env);
     return 0;
 }
 
 static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerGetSize_1tParameter
-  (JNIEnv *env, jclass clazz, jint recognizer, jstring key) {
+  (JNIEnv *env, jclass clazz, jlong recognizer, jstring key) {
     unimplemented(env);
     return 0;
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerGetBoolParameter
-  (JNIEnv *env, jclass clazz, jint recognizer, jstring key) {
+  (JNIEnv *env, jclass clazz, jlong recognizer, jstring key) {
     unimplemented(env);
     return JNI_FALSE;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetParameter
-  (JNIEnv *env, jclass clazz, jint recognizer, jstring key, jstring value) {
+  (JNIEnv *env, jclass clazz, jlong recognizer, jstring key, jstring value) {
     unimplemented(env);
     return;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetSize_1tParameter
-  (JNIEnv *env, jclass clazz, jint recognizer, jstring key, jint value) {
+  (JNIEnv *env, jclass clazz, jlong recognizer, jstring key, jint value) {
     unimplemented(env);
     return;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetBoolParameter
-  (JNIEnv *env, jclass clazz, jint recognizer, jstring key , jboolean value) {
+  (JNIEnv *env, jclass clazz, jlong recognizer, jstring key , jboolean value) {
     unimplemented(env);
     return;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetupRule
-        (JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jlong grammar, jstring ruleName) {
     const char* rn = env->GetStringUTFChars(ruleName, 0);
     checkEsrError(env, SR_RecognizerSetupRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn));
     env->ReleaseStringUTFChars(ruleName, rn);
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerHasSetupRules
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerHasSetupRules((SR_Recognizer*)recognizer, &rtn));
     return rtn;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerActivateRule
-        (JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName, jint weight) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jlong grammar, jstring ruleName, jint weight) {
     const char* rn = env->GetStringUTFChars(ruleName, 0);
     checkEsrError(env, SR_RecognizerActivateRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn, weight));
     env->ReleaseStringUTFChars(ruleName, rn);
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateRule
-        (JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jlong grammar, jstring ruleName) {
     const char* rn = env->GetStringUTFChars(ruleName, 0);
     checkEsrError(env, SR_RecognizerDeactivateRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn));
     env->ReleaseStringUTFChars(ruleName, rn);
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateAllRules
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     checkEsrError(env, SR_RecognizerDeactivateAllRules((SR_Recognizer*)recognizer));
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsActiveRule
-        (JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jlong grammar, jstring ruleName) {
     ESR_BOOL rtn = ESR_FALSE;
     const char* rn = env->GetStringUTFChars(ruleName, 0);
     checkEsrError(env, SR_RecognizerIsActiveRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn, &rtn));
@@ -230,14 +230,14 @@ static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1Recogn
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerCheckGrammarConsistency
-        (JNIEnv *env, jclass clazz, jint recognizer, jint grammar) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jlong grammar) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerCheckGrammarConsistency((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, &rtn));
     return rtn;
 }
 
 static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerPutAudio
-        (JNIEnv *env, jclass clazz, jint recognizer, jbyteArray audio, jint offset, jint length, jboolean isLast) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jbyteArray audio, jint offset, jint length, jboolean isLast) {
     // set the length
     jbyte buffer[1024];
     if (length > (int)sizeof(buffer)) length = sizeof(buffer);
@@ -259,7 +259,7 @@ static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1Recognizer
 }
 
 static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerAdvance
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     SR_RecognizerStatus status = SR_RECOGNIZER_EVENT_INVALID;
     SR_RecognizerResultType type = SR_RECOGNIZER_RESULT_TYPE_INVALID;
     SR_RecognizerResult* recognizerResult = NULL;
@@ -268,42 +268,42 @@ static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1Recognizer
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalClipping
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerIsSignalClipping((SR_Recognizer*)recognizer, &rtn));
     return rtn;
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalDCOffset
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerIsSignalDCOffset((SR_Recognizer*)recognizer, &rtn));
     return rtn;
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalNoisy
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerIsSignalNoisy((SR_Recognizer*)recognizer, &rtn));
     return rtn;
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooQuiet
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerIsSignalTooQuiet((SR_Recognizer*)recognizer, &rtn));
     return rtn;
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooFewSamples
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerIsSignalTooFewSamples((SR_Recognizer*)recognizer, &rtn));
     return rtn;
 }
 
 static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooManySamples
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     ESR_BOOL rtn = ESR_FALSE;
     checkEsrError(env, SR_RecognizerIsSignalTooManySamples((SR_Recognizer*)recognizer, &rtn));
     return rtn;
@@ -315,19 +315,19 @@ static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1Recogn
 //////////////////////////////////////////////////////////////////////////
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1AcousticStateReset
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     checkEsrError(env, SR_AcousticStateReset((SR_Recognizer*)recognizer));
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1AcousticStateSet
-        (JNIEnv *env, jclass clazz, jint recognizer, jstring state) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jstring state) {
     const char* st = env->GetStringUTFChars(state, 0);
     checkEsrError(env, SR_AcousticStateSet((SR_Recognizer*)recognizer, st));
     env->ReleaseStringUTFChars(state, st);
 }
 
 static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1AcousticStateGet
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     char rtn[1000];
     size_t rtnLength = sizeof(rtn) - 1;
     ESR_ReturnCode esr_status = SR_AcousticStateGet((SR_Recognizer*)recognizer, rtn, &rtnLength);
@@ -345,12 +345,12 @@ static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1Acousti
 //////////////////////////////////////////////////////////////////////////
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarCompile
-        (JNIEnv *env, jclass clazz, jint grammar) {
+        (JNIEnv *env, jclass clazz, jlong grammar) {
     checkEsrError(env, SR_GrammarCompile((SR_Grammar*)grammar));
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAddWordToSlot
-        (JNIEnv *env, jclass clazz, jint grammar, jstring slot, jstring word, jstring pronunciation, jint weight, jstring tag) {
+        (JNIEnv *env, jclass clazz, jlong grammar, jstring slot, jstring word, jstring pronunciation, jint weight, jstring tag) {
     const char* sl = 0;
     const char* wo = 0;
     const char* pr = 0;
@@ -368,63 +368,63 @@ static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAdd
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarResetAllSlots
-        (JNIEnv *env, jclass clazz, jint grammar) {
+        (JNIEnv *env, jclass clazz, jlong grammar) {
     checkEsrError(env, SR_GrammarResetAllSlots((SR_Grammar*)grammar));
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarSetupVocabulary
-        (JNIEnv *env, jclass clazz, jint grammar, jint vocabulary) {
+        (JNIEnv *env, jclass clazz, jlong grammar, jlong vocabulary) {
     checkEsrError(env, SR_GrammarSetupVocabulary((SR_Grammar*)grammar, (SR_Vocabulary*)vocabulary));
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarSetupRecognizer
-        (JNIEnv *env, jclass clazz, jint grammar, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong grammar, jlong recognizer) {
     checkEsrError(env, SR_GrammarSetupRecognizer((SR_Grammar*)grammar, (SR_Recognizer*)recognizer));
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarUnsetupRecognizer
-        (JNIEnv *env, jclass clazz, jint grammar) {
+        (JNIEnv *env, jclass clazz, jlong grammar) {
     checkEsrError(env, SR_GrammarUnsetupRecognizer((SR_Grammar*)grammar));
 }
 
-static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarCreate
+static JNIEXPORT jlong JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarCreate
         (JNIEnv *env, jclass clazz) {
     SR_Grammar* grammar = 0;
     checkEsrError(env, SR_GrammarCreate(&grammar));
-    return (jint)grammar;
+    return (jlong)grammar;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarDestroy
-        (JNIEnv *env, jclass clazz, jint grammar) {
+        (JNIEnv *env, jclass clazz, jlong grammar) {
     checkEsrError(env, SR_GrammarDestroy((SR_Grammar*)grammar));
 }
 
-static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarLoad
+static JNIEXPORT jlong JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarLoad
         (JNIEnv *env, jclass clazz, jstring fileName) {
     // TODO: check for fileName NPE
     SR_Grammar* grammar = 0;
     const char* fn = env->GetStringUTFChars(fileName, 0);
     checkEsrError(env, SR_GrammarLoad(fn, &grammar));
     env->ReleaseStringUTFChars(fileName, fn);
-    return (jint)grammar;
+    return (jlong)grammar;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarSave
-        (JNIEnv *env, jclass clazz, jint grammar, jstring fileName) {
+        (JNIEnv *env, jclass clazz, jlong grammar, jstring fileName) {
     const char* fn = env->GetStringUTFChars(fileName, 0);
     checkEsrError(env, SR_GrammarSave((SR_Grammar*)grammar, fn));
     env->ReleaseStringUTFChars(fileName, fn);
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAllowOnly
-        (JNIEnv *env, jclass clazz, jint grammar, jstring transcription) {
+        (JNIEnv *env, jclass clazz, jlong grammar, jstring transcription) {
     const char* tr = env->GetStringUTFChars(transcription, 0);
     checkEsrError(env, SR_GrammarSave((SR_Grammar*)grammar, tr));
     env->ReleaseStringUTFChars(transcription, tr);
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAllowAll
-        (JNIEnv *env, jclass clazz, jint grammar) {
+        (JNIEnv *env, jclass clazz, jlong grammar) {
     checkEsrError(env, SR_GrammarAllowAll((SR_Grammar*)grammar));
 }
 
@@ -433,7 +433,7 @@ static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAll
 // SR_Vocabulary JNI implementations
 //////////////////////////////////////////////////////////////////////////
 
-static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1VocabularyLoad
+static JNIEXPORT jlong JNICALL Java_android_speech_srec_Recognizer_SR_1VocabularyLoad
         (JNIEnv *env, jclass clazz) {
     char filename[P_PATH_MAX];
     size_t flen = sizeof(filename) - 1;
@@ -442,17 +442,17 @@ static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1Vocabulary
     // TODO: do we need to clean up the recognizer if this fails?
     SR_Vocabulary* vocabulary = NULL;
     checkEsrError(env, SR_VocabularyLoad(filename, &vocabulary));
-    return (jint)vocabulary;
+    return (jlong)vocabulary;
 }
 
 static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1VocabularyDestroy
-        (JNIEnv *env, jclass clazz, jint vocabulary) {
+        (JNIEnv *env, jclass clazz, jlong vocabulary) {
     // TODO: do we need to clean up the recognizer if this fails?
     checkEsrError(env, SR_VocabularyDestroy((SR_Vocabulary*)vocabulary));
 }
 
 static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1VocabularyGetPronunciation
-        (JNIEnv *env, jclass clazz, jint vocabulary, jstring word) {
+        (JNIEnv *env, jclass clazz, jlong vocabulary, jstring word) {
     char rtn[1000];
     size_t rtnLength = sizeof(rtn) - 1;
     const char* wo = env->GetStringUTFChars(word, 0);
@@ -472,27 +472,27 @@ static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1Vocabul
 //////////////////////////////////////////////////////////////////////////
 
 static JNIEXPORT jbyteArray JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetWaveform
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     unimplemented(env);
     return 0;
 }
 
 static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetSize
-        (JNIEnv *env, jclass clazz, jint recognizer) {
+        (JNIEnv *env, jclass clazz, jlong recognizer) {
     size_t size = 0;
     checkEsrError(env, SR_RecognizerResultGetSize(((SR_RecognizerImpl*)recognizer)->result, &size));
     return size;
 }
 
 static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyCount
-        (JNIEnv *env, jclass clazz, jint recognizer, jint nbest) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jint nbest) {
     size_t size = 0;
     checkEsrError(env, SR_RecognizerResultGetKeyCount(((SR_RecognizerImpl*)recognizer)->result, nbest, &size));
     return size;
 }
 
 static JNIEXPORT jobjectArray JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyList
-        (JNIEnv *env, jclass clazz, jint recognizer, jint nbest) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jint nbest) {
     // fetch list
     LCHAR* list[200];
     size_t listSize = sizeof(list) / sizeof(list[0]);
@@ -522,7 +522,7 @@ static JNIEXPORT jobjectArray JNICALL Java_android_speech_srec_Recognizer_SR_1Re
 }
 
 static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetValue
-        (JNIEnv *env, jclass clazz, jint recognizer, jint nbest, jstring key) {
+        (JNIEnv *env, jclass clazz, jlong recognizer, jint nbest, jstring key) {
     char rtn[1000];
     size_t rtnLength = sizeof(rtn) - 1;
     const char* ke = env->GetStringUTFChars(key, 0);
@@ -549,61 +549,61 @@ static JNINativeMethod gMethods[] = {
     {"SR_SessionCreate",                   "(Ljava/lang/String;)V",   (void*)Java_android_speech_srec_Recognizer_SR_1SessionCreate},
     {"SR_SessionDestroy",                  "()V",                     (void*)Java_android_speech_srec_Recognizer_SR_1SessionDestroy},
     // SR_Recognizer
-    {"SR_RecognizerStart",                 "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerStart},
-    {"SR_RecognizerStop",                  "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerStop},
-    {"SR_RecognizerCreate",                "()I",                     (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerCreate},
-    {"SR_RecognizerDestroy",               "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDestroy},
-    {"SR_RecognizerSetup",                 "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetup},
-    {"SR_RecognizerUnsetup",               "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerUnsetup},
-    {"SR_RecognizerIsSetup",               "(I)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSetup},
-    {"SR_RecognizerGetParameter",          "(ILjava/lang/String;)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetParameter},
-    {"SR_RecognizerGetSize_tParameter",    "(ILjava/lang/String;)I",  (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetSize_1tParameter},
-    {"SR_RecognizerGetBoolParameter",      "(ILjava/lang/String;)Z",  (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetBoolParameter},
-    {"SR_RecognizerSetParameter",          "(ILjava/lang/String;Ljava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetParameter},
-    {"SR_RecognizerSetSize_tParameter",    "(ILjava/lang/String;I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetSize_1tParameter},
-    {"SR_RecognizerSetBoolParameter",      "(ILjava/lang/String;Z)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetBoolParameter},
-    {"SR_RecognizerSetupRule",             "(IILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetupRule},
-    {"SR_RecognizerHasSetupRules",         "(I)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerHasSetupRules},
-    {"SR_RecognizerActivateRule",          "(IILjava/lang/String;I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerActivateRule},
-    {"SR_RecognizerDeactivateRule",        "(IILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateRule},
-    {"SR_RecognizerDeactivateAllRules",    "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateAllRules},
-    {"SR_RecognizerIsActiveRule",          "(IILjava/lang/String;)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsActiveRule},
-    {"SR_RecognizerCheckGrammarConsistency", "(II)Z",                 (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerCheckGrammarConsistency},
-    {"SR_RecognizerPutAudio",              "(I[BIIZ)I",               (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerPutAudio},
-    {"SR_RecognizerAdvance",               "(I)I",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerAdvance},
-    {"SR_RecognizerIsSignalClipping",      "(I)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalClipping},
-    {"SR_RecognizerIsSignalDCOffset",      "(I)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalDCOffset},
-    {"SR_RecognizerIsSignalNoisy",         "(I)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalNoisy},
-    {"SR_RecognizerIsSignalTooQuiet",      "(I)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooQuiet},
-    {"SR_RecognizerIsSignalTooFewSamples", "(I)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooFewSamples},
-    {"SR_RecognizerIsSignalTooManySamples", "(I)Z",                   (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooManySamples},
+    {"SR_RecognizerStart",                 "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerStart},
+    {"SR_RecognizerStop",                  "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerStop},
+    {"SR_RecognizerCreate",                "()J",                     (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerCreate},
+    {"SR_RecognizerDestroy",               "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDestroy},
+    {"SR_RecognizerSetup",                 "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetup},
+    {"SR_RecognizerUnsetup",               "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerUnsetup},
+    {"SR_RecognizerIsSetup",               "(J)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSetup},
+    {"SR_RecognizerGetParameter",          "(JLjava/lang/String;)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetParameter},
+    {"SR_RecognizerGetSize_tParameter",    "(JLjava/lang/String;)I",  (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetSize_1tParameter},
+    {"SR_RecognizerGetBoolParameter",      "(JLjava/lang/String;)Z",  (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetBoolParameter},
+    {"SR_RecognizerSetParameter",          "(JLjava/lang/String;Ljava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetParameter},
+    {"SR_RecognizerSetSize_tParameter",    "(JLjava/lang/String;I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetSize_1tParameter},
+    {"SR_RecognizerSetBoolParameter",      "(JLjava/lang/String;Z)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetBoolParameter},
+    {"SR_RecognizerSetupRule",             "(JJLjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetupRule},
+    {"SR_RecognizerHasSetupRules",         "(J)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerHasSetupRules},
+    {"SR_RecognizerActivateRule",          "(JJLjava/lang/String;I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerActivateRule},
+    {"SR_RecognizerDeactivateRule",        "(JJLjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateRule},
+    {"SR_RecognizerDeactivateAllRules",    "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateAllRules},
+    {"SR_RecognizerIsActiveRule",          "(JJLjava/lang/String;)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsActiveRule},
+    {"SR_RecognizerCheckGrammarConsistency", "(JJ)Z",                 (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerCheckGrammarConsistency},
+    {"SR_RecognizerPutAudio",              "(J[BIIZ)I",               (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerPutAudio},
+    {"SR_RecognizerAdvance",               "(J)I",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerAdvance},
+    {"SR_RecognizerIsSignalClipping",      "(J)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalClipping},
+    {"SR_RecognizerIsSignalDCOffset",      "(J)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalDCOffset},
+    {"SR_RecognizerIsSignalNoisy",         "(J)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalNoisy},
+    {"SR_RecognizerIsSignalTooQuiet",      "(J)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooQuiet},
+    {"SR_RecognizerIsSignalTooFewSamples", "(J)Z",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooFewSamples},
+    {"SR_RecognizerIsSignalTooManySamples", "(J)Z",                   (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooManySamples},
     // SR_AcousticState
-    {"SR_AcousticStateReset",               "(I)V",                   (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateReset},
-    {"SR_AcousticStateSet",                 "(ILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateSet},
-    {"SR_AcousticStateGet",                 "(I)Ljava/lang/String;",  (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateGet},
+    {"SR_AcousticStateReset",               "(J)V",                   (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateReset},
+    {"SR_AcousticStateSet",                 "(JLjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateSet},
+    {"SR_AcousticStateGet",                 "(J)Ljava/lang/String;",  (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateGet},
     // SR_Grammar
-    {"SR_GrammarCompile",                  "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarCompile},
-    {"SR_GrammarAddWordToSlot",            "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAddWordToSlot},
-    {"SR_GrammarResetAllSlots",            "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarResetAllSlots},
-    {"SR_GrammarSetupVocabulary",          "(II)V",                   (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSetupVocabulary},
-    {"SR_GrammarSetupRecognizer",          "(II)V",                   (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSetupRecognizer},
-    {"SR_GrammarUnsetupRecognizer",        "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarUnsetupRecognizer},
-    {"SR_GrammarCreate",                   "()I",                     (void*)Java_android_speech_srec_Recognizer_SR_1GrammarCreate},
-    {"SR_GrammarDestroy",                  "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarDestroy},
-    {"SR_GrammarLoad",                     "(Ljava/lang/String;)I",   (void*)Java_android_speech_srec_Recognizer_SR_1GrammarLoad},
-    {"SR_GrammarSave",                     "(ILjava/lang/String;)V",  (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSave},
-    {"SR_GrammarAllowOnly",                "(ILjava/lang/String;)V",  (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAllowOnly},
-    {"SR_GrammarAllowAll",                 "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAllowAll},
+    {"SR_GrammarCompile",                  "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarCompile},
+    {"SR_GrammarAddWordToSlot",            "(JLjava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAddWordToSlot},
+    {"SR_GrammarResetAllSlots",            "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarResetAllSlots},
+    {"SR_GrammarSetupVocabulary",          "(JJ)V",                   (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSetupVocabulary},
+    {"SR_GrammarSetupRecognizer",          "(JJ)V",                   (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSetupRecognizer},
+    {"SR_GrammarUnsetupRecognizer",        "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarUnsetupRecognizer},
+    {"SR_GrammarCreate",                   "()J",                     (void*)Java_android_speech_srec_Recognizer_SR_1GrammarCreate},
+    {"SR_GrammarDestroy",                  "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarDestroy},
+    {"SR_GrammarLoad",                     "(Ljava/lang/String;)J",   (void*)Java_android_speech_srec_Recognizer_SR_1GrammarLoad},
+    {"SR_GrammarSave",                     "(JLjava/lang/String;)V",  (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSave},
+    {"SR_GrammarAllowOnly",                "(JLjava/lang/String;)V",  (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAllowOnly},
+    {"SR_GrammarAllowAll",                 "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAllowAll},
     // SR_Vocabulary
-    {"SR_VocabularyLoad",                  "()I",                     (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyLoad},
-    {"SR_VocabularyDestroy",               "(I)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyDestroy},
-    {"SR_VocabularyGetPronunciation",      "(ILjava/lang/String;)Ljava/lang/String;",  (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyGetPronunciation},
+    {"SR_VocabularyLoad",                  "()J",                     (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyLoad},
+    {"SR_VocabularyDestroy",               "(J)V",                    (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyDestroy},
+    {"SR_VocabularyGetPronunciation",      "(JLjava/lang/String;)Ljava/lang/String;",  (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyGetPronunciation},
     // SR_RecognizerResult
-    {"SR_RecognizerResultGetWaveform",     "(I)[B",                   (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetWaveform},
-    {"SR_RecognizerResultGetSize",         "(I)I",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetSize},
-    {"SR_RecognizerResultGetKeyCount",     "(II)I",                   (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyCount},
-    {"SR_RecognizerResultGetKeyList",      "(II)[Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyList},
-    {"SR_RecognizerResultGetValue",        "(IILjava/lang/String;)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetValue},
+    {"SR_RecognizerResultGetWaveform",     "(J)[B",                   (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetWaveform},
+    {"SR_RecognizerResultGetSize",         "(J)I",                    (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetSize},
+    {"SR_RecognizerResultGetKeyCount",     "(JI)I",                   (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyCount},
+    {"SR_RecognizerResultGetKeyList",      "(JI)[Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyList},
+    {"SR_RecognizerResultGetValue",        "(JILjava/lang/String;)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetValue},
 };
 
 /*