/** * Create Java String object from the specified pcsl_string. * * @param pcsl_str pointer to the pcsl_string instance * @param java_str pointer to the Java String instance * @return status of the operation */ pcsl_string_status midp_jstring_from_pcsl_string(KNIDECLARGS const pcsl_string * pcsl_str, jstring java_str) { if (pcsl_str == NULL) { KNI_ReleaseHandle(java_str); return PCSL_STRING_EINVAL; } else { const jsize length = pcsl_string_utf16_length(pcsl_str); if (length < 0) { KNI_ReleaseHandle(java_str); return PCSL_STRING_EINVAL; } else { const jchar * buffer = pcsl_string_get_utf16_data(pcsl_str); if (buffer == NULL) { KNI_ReleaseHandle(java_str); return PCSL_STRING_ERR; } else { KNI_NewString(buffer, length, java_str); return PCSL_STRING_OK; } } } }
/** * Writes string to the file. * * @param string string to be written * @return number of bytes written */ static int write_string(const pcsl_string* string) { int size = pcsl_string_utf16_length(string) * sizeof(jchar); const jchar *buf = pcsl_string_get_utf16_data(string); storageWrite(&io_error_message, table_file, (char *)&size, sizeof(int)); storageWrite(&io_error_message, table_file, (char *)buf, size); pcsl_string_release_utf16_data(buf, string); return sizeof(int) + size; }
/** * Utility for serialized handler appending. */ static void appendSerializedCH(const JSR211_CH* ch, jchar* buf) { jsize n; n = pcsl_string_utf16_length(&(ch->id)); if (n > 0) { pcsl_string_convert_to_utf16(&(ch->id), buf, n+1, &n); buf += n; } *buf++ = '\n'; n = pcsl_string_utf16_length(&(ch->class_name)); if (n > 0) { pcsl_string_convert_to_utf16(&(ch->class_name), buf, n+1, &n); buf += n; } *buf++ = '\n'; *buf++ = (jchar)(ch->suite_id >> 16); *buf++ = (jchar)ch->suite_id; *buf = (jchar)ch->flag; }
/** * compare_two_strings wrapper. * Reads a string from a current field of a current * record and compares it with a passed value. * * @param key compare key * @param case_sensitive case sensivity flag * @param cond internal ID of comparision mode * @return 1 if strings are equal (for the given mode) */ static int compare_string(const pcsl_string* search_key, jsr211_boolean case_sensitive, find_condition cond) { pcsl_string string = PCSL_STRING_NULL_INITIALIZER; int compare_result; int exact_result, first_result; int equal_count, string_len; read_string(&string); string_len = pcsl_string_utf16_length(&string); compare_result = cond != find_last ? compare_two_strings(&string, search_key, case_sensitive): pcsl_string_ends_with(search_key, &string); pcsl_string_free(&string); exact_result = compare_result == 0; if (cond == find_last) { return compare_result; } if (cond == find_exact) { return exact_result; } equal_count = compare_result - 1; first_result = (equal_count == string_len) || exact_result; if (cond == find_first) { return first_result; } if (cond == find_test) { return first_result || equal_count == pcsl_string_utf16_length(search_key); } return 0; }
/** * Compares two MIDP strings. * * The distinction from midpStringCmp is a posibility of * partly equal strings recognition * * @param str1 the first string to be comapred * @param str2 the second string to be comapred * @param case_sensitive indicates case sensivity * @return 0 if strings are equals; if strings are * different returns number of the first different symbol */ static int compare_two_strings(const pcsl_string *str1, const pcsl_string *str2, jsr211_boolean case_sensitive) { const jchar *buf1, *buf2, *cur1, *cur2; int i, n, res; cur1 = buf1 = pcsl_string_get_utf16_data(str1); cur2 = buf2 = pcsl_string_get_utf16_data(str2); n = pcsl_string_utf16_length(str1); i = pcsl_string_utf16_length(str2); res = n == i? 0: n < i? n: i; if (res != 0) { n = res++; } i = 0; if (!case_sensitive) { while (i++ < n) { if (to_lower_case(*cur1++) != to_lower_case(*cur2++)) { res = i; break; } } } else { while (i++ < n) { if (*cur1++ != *cur2++) { res = i; break; } } } pcsl_string_release_utf16_data(buf1, str1); pcsl_string_release_utf16_data(buf2, str2); return res; }
/** * The function that will be called when Java system state * changes. * * @param pEventData */ void system_state_listener(const NamsEventData* pEventData) { printf("--- system_state_listener(event = %d, state = %d)\n", pEventData->event, pEventData->state); if (pEventData->event == MIDP_NAMS_EVENT_STATE_CHANGED && pEventData->state == MIDP_SYSTEM_STATE_ACTIVE) { int i; const jchar *jchArgsForMidlet[3]; jint argsLen[3]; /* Currently we support up to 3 arguments. */ for (i = 0; i < 3; i++) { jchArgsForMidlet[i] = pcsl_string_get_utf16_data(&argsForMidlet[i]); argsLen[i] = pcsl_string_utf16_length(&argsForMidlet[i]); } GET_PCSL_STRING_DATA_AND_LENGTH(aclassNameToRun) (void) midp_midlet_create_start_with_args(suiteIDToRun, (const jchar*)aclassNameToRun_data, aclassNameToRun_len, (const jchar**)jchArgsForMidlet, argsLen, 3, #if ENABLE_I3_TEST findNextEmptyMIDlet(0), #else /* * There is only one application * excepting namsTestService mode */ 1, #endif NULL); RELEASE_PCSL_STRING_DATA_AND_LENGTH for (i = 0; i < 3; i++) { pcsl_string_release_utf16_data(jchArgsForMidlet[i], &argsForMidlet[i]); } }
/** * Fills output result structure with string array. * @param strArray string array. * @param length array length. * @param result output result structure. * @return operation status. */ jsr211_result jsr211_fillStringArray(const pcsl_string* strArr, int length, /*OUT*/ JSR211_RESULT_STRARRAY* result) { jsize cap, len, siz; // buffer capacity, used length, requested size jchar* buf; if (strArr == NULL || length <= 0) { result->len = 0; result->buf = NULL; } else { _INIT_BUFFER_(buf, cap) for (*buf = (jchar)length, len = 1; length--; len += siz, strArr++) { siz = pcsl_string_utf16_length(strArr); _ASSURE_BUFFER_(buf, cap, len + siz + 2) buf[len++] = siz; pcsl_string_convert_to_utf16(strArr, buf + len, siz+1, &siz); } result->len = len; result->buf = buf; } return JSR211_OK; }
/** * Writes the file with information about the installed suites. * * Note that if the value of the global variable g_numberOfSuites * is zero, the file will be truncated. * * @param ppszError pointer to character string pointer to accept an error * * @return status code: ALL_OK if no errors, * OUT_OF_MEMORY if malloc failed * IO_ERROR if an IO_ERROR */ MIDPError write_suites_data(char** ppszError) { MIDPError status = ALL_OK; long bufferLen, pos; char* buffer = NULL; pcsl_string_status rc; pcsl_string suitesDataFile; MidletSuiteData* pData; *ppszError = NULL; /* get a full path to the _suites.dat */ rc = pcsl_string_cat(storage_get_root(INTERNAL_STORAGE_ID), &SUITE_DATA_FILENAME, &suitesDataFile); if (rc != PCSL_STRING_OK) { return OUT_OF_MEMORY; } if (!g_numberOfSuites) { /* truncate the file with the list of the installed suites */ status = write_file(ppszError, &suitesDataFile, buffer, 0); pcsl_string_free(&suitesDataFile); return status; } /* allocate a buffer where the information about all suites will be saved */ bufferLen = g_numberOfSuites * (sizeof(MidletSuiteData) + MAX_VAR_SUITE_DATA_LEN); /* space to store the number of suites */ bufferLen += sizeof(int); buffer = (char*)pcsl_mem_malloc(bufferLen); if (buffer == NULL) { pcsl_string_free(&suitesDataFile); return OUT_OF_MEMORY; } /* assemble the information about all suites into the allocated buffer */ pos = 0; pData = g_pSuitesData; *(int*)&buffer[pos] = g_numberOfSuites; ADJUST_POS_IN_BUF(pos, bufferLen, sizeof(int)); while (pData != NULL) { memcpy((char*)&buffer[pos], (char*)pData, MIDLET_SUITE_DATA_SIZE); ADJUST_POS_IN_BUF(pos, bufferLen, MIDLET_SUITE_DATA_SIZE); /* setup pJarHash */ if (pData->jarHashLen > 0) { memcpy((char*)&buffer[pos], pData->varSuiteData.pJarHash, pData->jarHashLen); ADJUST_POS_IN_BUF(pos, bufferLen, pData->jarHashLen); } /* setup string fields */ { int i, convertedLen; jint strLen; pcsl_string* pStrings[] = { &pData->varSuiteData.midletClassName, &pData->varSuiteData.displayName, &pData->varSuiteData.iconName, &pData->varSuiteData.suiteVendor, &pData->varSuiteData.suiteName, &pData->varSuiteData.pathToJar, &pData->varSuiteData.pathToSettings }; status = ALL_OK; for (i = 0; i < (int) (sizeof(pStrings) / sizeof(pStrings[0])); i++) { strLen = pcsl_string_utf16_length(pStrings[i]); /* * We have to guarantee 4 - bytes alignment to use this: * *(jint*)&buffer[pos] = strLen; * on RISC CPUs. */ pos = SUITESTORE_ALIGN_4(pos); *(jint*)&buffer[pos] = strLen; ADJUST_POS_IN_BUF(pos, bufferLen, sizeof(jint)); /* assert(bufferLen > 0); */ if (strLen > 0) { rc = pcsl_string_convert_to_utf16(pStrings[i], (jchar*)&buffer[pos], bufferLen / sizeof(jchar), &convertedLen); if (rc != PCSL_STRING_OK) { status = OUT_OF_MEMORY; break; } ADJUST_POS_IN_BUF(pos, bufferLen, convertedLen * sizeof(jchar)); } } } if (status != ALL_OK) { break; } pData = pData->nextEntry; } if (status == ALL_OK) { /* write the buffer into the file */ status = write_file(ppszError, &suitesDataFile, buffer, pos); } /* cleanup */ pcsl_mem_free(buffer); pcsl_string_free(&suitesDataFile); return status; }
/** * Version string may looks like Major:Minor:Micro * * @param ver pcsl_string that contains a version * @param major Major version * @param minor Minor version * @param micro Micro version * @return 1 == OK * 0 = BAD version */ int midpGetVersion(const pcsl_string * ver, int *major, int *minor, int *micro) { int ma = 0; int mi = 0; int mc = 0; int count = 0; int dot_count = 0; int segment_size = 0; const jchar* p = NULL; const jchar* ver_data; jsize ver_len = pcsl_string_utf16_length(ver); *major = -1; *minor = -1; *micro = -1; if ((ver_len <= 0) || (ver_len > 8)) { return 0; } printPcslStringWithMessage("ver", ver); ver_data = pcsl_string_get_utf16_data(ver); if (NULL == ver_data) { return 0; } /* most checking done here */ for (count=0; count < ver_len; count++) { if ((ver_data[count] >= '0') && (ver_data[count] <= '9')) { segment_size++; } else if (ver_data[count] == '.') { if ((segment_size == 0) || (segment_size > 2)) { REPORT_ERROR1(LC_AMS, "segment size wrong %d", segment_size); pcsl_string_release_utf16_data(ver_data, ver); return 0; } dot_count++; segment_size = 0; } else { pcsl_string_release_utf16_data(ver_data, ver); return 0; } } /* end of for */ /* can't be more then 2 dots in version */ if (dot_count > 2) { REPORT_ERROR1(LC_AMS, "too many dots (%d)", dot_count); pcsl_string_release_utf16_data(ver_data, ver); return 0; } /* * Get major version */ for (p = ver_data, count = 0; (*p != '.') && (count < ver_len); ) { if (*p >= '0' && *p <= '9') { ma *= 10; ma += *p - '0'; } else { pcsl_string_release_utf16_data(ver_data, ver); return 0; } count++; p++; } /* end of for */ if(*p == '.') { p++; count++; } /* * Get minor version. */ for ( ; (*p != '.') && (count < ver_len); ) { if (*p >= '0' && *p <= '9') { mi *= 10; mi += *p - '0'; } else { pcsl_string_release_utf16_data(ver_data, ver); return 0; } count++; p++; } if(*p == '.') { p++; count++; } /* * Get micro version; if it exists.. */ for ( ; (*p != '.') && (count < ver_len); ) { if (*p >= '0' && *p <= '9') { mc *= 10; mc += *p - '0'; } else { pcsl_string_release_utf16_data(ver_data, ver); return 0; } p++; count++; } *major = ma; *minor = mi; *micro = mc; pcsl_string_release_utf16_data(ver_data, ver); return 1; }
/** * Utility for needed size counting. */ static jsize getSerializedCHSize(const JSR211_CH* ch) { return pcsl_string_utf16_length(&(ch->id)) + pcsl_string_utf16_length(&(ch->class_name)) + 5; }