void RawCom4::increment(int steps) {
long start;
unsigned long size;
VerseKey *tmpkey = &getVerseKey();
findOffset(tmpkey->getTestament(), tmpkey->getTestamentIndex(), &start, &size);
SWKey lastgood = *tmpkey;
while (steps) {
long laststart = start;
unsigned long lastsize = size;
SWKey lasttry = *tmpkey;
(steps > 0) ? ++(*key) : --(*key);
tmpkey = &getVerseKey();
if ((error = key->popError())) {
*key = lastgood;
break;
}
long index = tmpkey->getTestamentIndex();
findOffset(tmpkey->getTestament(), index, &start, &size);
if (
(((laststart != start) || (lastsize != size)) // we're a different entry
// && (start > 0)
&& (size)) // and we actually have a size
||(!skipConsecutiveLinks)) { // or we don't want to skip consecutive links
steps += (steps < 0) ? 1 : -1;
lastgood = *tmpkey;
}
}
error = (error) ? KEYERR_OUTOFBOUNDS : 0;
}
bool RawCom4::isLinked(const SWKey *k1, const SWKey *k2) const {
long start1, start2;
unsigned long size1, size2;
VerseKey *vk1 = &getVerseKey(k1);
VerseKey *vk2 = &getVerseKey(k2);
if (vk1->getTestament() != vk2->getTestament()) return false;
findOffset(vk1->getTestament(), vk1->getTestamentIndex(), &start1, &size1);
findOffset(vk2->getTestament(), vk2->getTestamentIndex(), &start2, &size2);
if (!size1 || !size2) return false;
return start1 == start2;
}
bool zCom::isLinked(const SWKey *k1, const SWKey *k2) const {
long start1, start2;
unsigned short size1, size2;
unsigned long buffnum1, buffnum2;
VerseKey *vk1 = &getVerseKey(k1);
VerseKey *vk2 = &getVerseKey(k2);
if (vk1->Testament() != vk2->Testament()) return false;
findOffset(vk1->Testament(), vk1->TestamentIndex(), &start1, &size1, &buffnum1);
findOffset(vk2->Testament(), vk2->TestamentIndex(), &start2, &size2, &buffnum2);
return start1 == start2 && buffnum1 == buffnum2;
}
SWBuf &RawFiles::getRawEntryBuf() {
FileDesc *datafile;
long start = 0;
unsigned short size = 0;
VerseKey *key = &getVerseKey();
findOffset(key->Testament(), key->TestamentIndex(), &start, &size);
entryBuf = "";
if (size) {
SWBuf tmpbuf = path;
tmpbuf += '/';
readText(key->Testament(), start, size, entryBuf);
tmpbuf += entryBuf;
entryBuf = "";
datafile = FileMgr::getSystemFileMgr()->open(tmpbuf.c_str(), FileMgr::RDONLY);
if (datafile->getFd() > 0) {
size = datafile->seek(0, SEEK_END);
char *tmpBuf = new char [ size + 1 ];
memset(tmpBuf, 0, size + 1);
datafile->seek(0, SEEK_SET);
datafile->read(tmpBuf, size);
entryBuf = tmpBuf;
delete [] tmpBuf;
// preptext(entrybuf);
}
FileMgr::getSystemFileMgr()->close(datafile);
}
return entryBuf;
}
void RawFiles::setEntry(const char *inbuf, long len) {
FileDesc *datafile;
long start;
unsigned short size;
VerseKey *key = &getVerseKey();
len = (len<0)?strlen(inbuf):len;
findOffset(key->Testament(), key->TestamentIndex(), &start, &size);
if (size) {
SWBuf tmpbuf;
entryBuf = path;
entryBuf += '/';
readText(key->Testament(), start, size, tmpbuf);
entryBuf += tmpbuf;
}
else {
SWBuf tmpbuf;
entryBuf = path;
entryBuf += '/';
tmpbuf = getNextFilename();
doSetText(key->Testament(), key->TestamentIndex(), tmpbuf);
entryBuf += tmpbuf;
}
datafile = FileMgr::getSystemFileMgr()->open(entryBuf, FileMgr::CREAT|FileMgr::WRONLY|FileMgr::TRUNC);
if (datafile->getFd() > 0) {
datafile->write(inbuf, len);
}
FileMgr::getSystemFileMgr()->close(datafile);
}
QByteArray QResource::data(const QString &path) const
{
const int node = findNode(path);
if(node == -1)
return QByteArray();
int offset = findOffset(node) + 4; //jump past name
const short flags = (tree[offset+0] << 8) + (tree[offset+1] << 0);
offset += 2;
offset += 4; //jump past locale
QByteArray ret;
if(!(flags & Directory)) {
const int data_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
(tree[offset+2] << 8) + (tree[offset+3] << 0);
const uint data_length = (payloads[data_offset+0] << 24) + (payloads[data_offset+1] << 16) +
(payloads[data_offset+2] << 8) + (payloads[data_offset+3] << 0);
const uchar *data = payloads+data_offset+4;
#ifndef QT_NO_COMPRESS
if(flags & Compressed)
ret = qUncompress(data, data_length);
else
ret = QByteArray((char*)data, data_length);
#else
Q_ASSERT_X(!(flags & Compressed), "QResource::data",
"Qt built without support for compression");
#endif
}
return ret;
}
short QResourceRoot::flags(int node) const
{
if(node == -1)
return 0;
const int offset = findOffset(node) + 4; //jump past name
return (tree[offset+0] << 8) + (tree[offset+1] << 0);
}
const uchar *QResourceRoot::data(int node, qint64 *size) const
{
if(node == -1) {
*size = 0;
return 0;
}
int offset = findOffset(node) + 4; //jump past name
const short flags = (tree[offset+0] << 8) + (tree[offset+1] << 0);
offset += 2;
offset += 4; //jump past locale
if(!(flags & Directory)) {
const int data_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
(tree[offset+2] << 8) + (tree[offset+3] << 0);
const uint data_length = (payloads[data_offset+0] << 24) + (payloads[data_offset+1] << 16) +
(payloads[data_offset+2] << 8) + (payloads[data_offset+3] << 0);
const uchar *ret = payloads+data_offset+4;
*size = data_length;
return ret;
}
*size = 0;
return 0;
}
char RawLD::getEntry(long away) const
{
uint32_t start = 0;
uint16_t size = 0;
char *idxbuf = 0;
char retval = 0;
char *buf = new char [ strlen(*key) + 6 ];
strcpy(buf, *key);
if (strongsPadding) strongsPad(buf);
if (!(retval = findOffset(buf, &start, &size, away))) {
readText(start, &size, &idxbuf, entryBuf);
rawFilter(entryBuf, 0); // hack, decipher
rawFilter(entryBuf, key);
entrySize = size; // support getEntrySize call
if (!key->isPersist()) // If we have our own key
*key = idxbuf; // reset it to entry index buffer
stdstr(&entkeytxt, idxbuf); // set entry key text that module 'snapped' to.
delete [] idxbuf;
}
else {
entryBuf = "";
}
delete [] buf;
return retval;
}
bool RawCom4::hasEntry(const SWKey *k) const {
long start;
unsigned long size;
VerseKey *vk = &getVerseKey(k);
findOffset(vk->getTestament(), vk->getTestamentIndex(), &start, &size);
return size;
}
bool QResource::isContainer(const QString &path) const
{
int node = findNode(path);
if(node == -1)
return false;
const int offset = findOffset(node) + 4; //jump past name
const short flags = (tree[offset+0] << 8) + (tree[offset+1] << 0);
return flags & Directory;
}
int main(int argc, char *argv[])
{
char str[256];
int i=0;
unsigned char val;
int offset;
while(argc != 3){
return 0;
}
memcpy(str, argv[1], strlen(argv[1]));
str[strlen(argv[1])] = '\0';
memcpy(filename, argv[2], strlen(argv[2]));
filename[strlen(argv[2])] = '\0';
//printf("Please enter file name\n");
//scanf("%s",filename);
//printf("Please enter byte pattern to match\n");
//scanf("%s",str);
length = strlen(str);
if(length %2 != 0)
{
//printf("invalid pattern length\n");
goto DONE;
}
/*Convert ascii to hex, check for invalid characters*/
for(i=0;i<length;i++)
{
val = ascii_to_hex(str[i]);
if(val == 0xff)
{
//printf("Invalid character\n");
goto DONE;
}
else
{
if((i&1) == 0)
val <<= 4;
pattern[i>>1] |= val;
}
}
length = length/2;
offset = findOffset();
if(offset != -1)
printf("%d\n",offset);
DONE:
if(buffer)
free(buffer);
return 0;
bool zCom::hasEntry(const SWKey *k) const {
long start;
unsigned short size;
unsigned long buffnum;
VerseKey *vk = &getVerseKey(k);
findOffset(vk->Testament(), vk->TestamentIndex(), &start, &size, &buffnum);
return size;
}
inline int QResourceRoot::hash(int node) const
{
if(!node) //root
return 0;
const int offset = findOffset(node);
int name_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
(tree[offset+2] << 8) + (tree[offset+3] << 0);
name_offset += 2; //jump past name length
return (names[name_offset+0] << 24) + (names[name_offset+1] << 16) +
(names[name_offset+2] << 8) + (names[name_offset+3] << 0);
}
void RawStr::readText(__u32 istart, __u16 *isize, char **idxbuf, SWBuf &buf) const
{
unsigned int ch;
char *idxbuflocal = 0;
getIDXBufDat(istart, &idxbuflocal);
__u32 start = istart;
do {
if (*idxbuf)
delete [] *idxbuf;
buf = "";
buf.setFillByte(0);
buf.setSize(++(*isize));
*idxbuf = new char [ (*isize) ];
datfd->seek(start, SEEK_SET);
datfd->read(buf.getRawData(), (int)((*isize) - 1));
for (ch = 0; buf[ch]; ch++) { // skip over index string
if (buf[ch] == 10) {
ch++;
break;
}
}
buf = SWBuf(buf.c_str()+ch);
// resolve link
if (!strncmp(buf.c_str(), "@LINK", 5)) {
for (ch = 0; buf[ch]; ch++) { // null before nl
if (buf[ch] == 10) {
buf[ch] = 0;
break;
}
}
findOffset(buf.c_str() + 6, &start, isize);
}
else break;
}
while (true); // while we're resolving links
if (idxbuflocal) {
int localsize = strlen(idxbuflocal);
localsize = (localsize < (*isize - 1)) ? localsize : (*isize - 1);
strncpy(*idxbuf, idxbuflocal, localsize);
(*idxbuf)[localsize] = 0;
free(idxbuflocal);
}
}
long RawLD4::getEntryForKey(const char *key) const {
__u32 start, offset;
__u32 size;
char *buf = new char [ strlen(key) + 6 ];
strcpy(buf, key);
strongsPad(buf);
findOffset(buf, &start, &size, 0, &offset);
delete [] buf;
return offset / IDXENTRYSIZE;
}
static char* getPreferredTag(char* gf_tag)
{
char* result = NULL;
int grOffset = 0;
grOffset = findOffset( LOC_GRANDFATHERED ,gf_tag);
if( grOffset < LOC_PREFERRED_GRANDFATHERED_LEN ){
/* return preferred tag */
result = estrdup( LOC_PREFERRED_GRANDFATHERED[grOffset] );
} else {
/* Return correct grandfathered language tag */
result = estrdup( LOC_GRANDFATHERED[grOffset] );
}
return result;
}
long RawLD::getEntryForKey(const char *key) const {
uint32_t start, offset;
uint16_t size;
char *buf = new char [ strlen(key) + 6 ];
strcpy(buf, key);
if (strongsPadding) strongsPad(buf);
findOffset(buf, &start, &size, 0, &offset);
delete [] buf;
return offset / IDXENTRYSIZE;
}
void RawStr4::readText(uint32_t istart, uint32_t *isize, char **idxbuf, std::string &buf) const
{
unsigned int ch;
char *idxbuflocal = 0;
getIDXBufDat(istart, &idxbuflocal);
uint32_t start = istart;
do {
if (*idxbuf)
delete [] *idxbuf;
buf.clear();
buf.resize(++(*isize), '\0');
*idxbuf = new char [ (*isize) ];
datfd->seek(start, SEEK_SET);
datfd->read(&buf[0u], (int)((*isize) - 1));
for (ch = 0; buf[ch]; ch++) { // skip over index string
if (buf[ch] == 10) {
ch++;
break;
}
}
buf = std::string(buf.c_str()+ch);
// resolve link
if (!strncmp(buf.c_str(), "@LINK", 5)) {
for (ch = 0; buf[ch]; ch++) { // null before nl
if (buf[ch] == 10) {
buf[ch] = 0;
break;
}
}
findOffset(buf.c_str() + 6, &start, isize);
}
else break;
}
while (true); // while we're resolving links
if (idxbuflocal) {
unsigned int localsize = strlen(idxbuflocal);
localsize = (localsize < (*isize - 1)) ? localsize : (*isize - 1);
strncpy(*idxbuf, idxbuflocal, localsize);
(*idxbuf)[localsize] = 0;
free(idxbuflocal);
}
}
void RawFiles::linkEntry(const SWKey *inkey) {
long start;
unsigned short size;
const VerseKey *key = &getVerseKey();
findOffset(key->Testament(), key->TestamentIndex(), &start, &size);
if (size) {
SWBuf tmpbuf;
readText(key->Testament(), start, size + 2, tmpbuf);
key = &getVerseKey(inkey);
doSetText(key->Testament(), key->TestamentIndex(), tmpbuf.c_str());
}
}
inline QString QResourceRoot::name(int node) const
{
if(!node) // root
return QString();
const int offset = findOffset(node);
QString ret;
int name_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
(tree[offset+2] << 8) + (tree[offset+3] << 0);
const short name_length = (names[name_offset+0] << 8) +
(names[name_offset+1] << 0);
name_offset += 2;
name_offset += 4; //jump past hash
for(int i = 0; i < name_length*2; i+=2)
ret += QChar(names[name_offset+i+1], names[name_offset+i]);
return ret;
}
std::string HREFCom::getRawEntryImpl() const {
StartType start;
SizeType size;
VerseKey * key_ = nullptr;
key_ = &getVerseKey();
findOffset(key_->getTestament(), key_->getTestamentIndex(), &start, &size);
entrySize = size; // support getEntrySize call
std::string entry;
readText(key_->getTestament(), start, size, entry);
if (key_ != this->key)
delete key_;
return m_prefix + entry;
}
/******************************************************************************
* zCom::getRawEntry - Returns the correct verse when char * cast
* is requested
*
* RET: string buffer with verse
*/
SWBuf &zCom::getRawEntryBuf() {
long start = 0;
unsigned short size = 0;
unsigned long buffnum;
VerseKey *key = &getVerseKey();
findOffset(key->Testament(), key->TestamentIndex(), &start, &size, &buffnum);
entrySize = size; // support getEntrySize call
entryBuf = "";
zReadText(key->Testament(), start, size, buffnum, entryBuf);
rawFilter(entryBuf, key);
// if (!isUnicode())
prepText(entryBuf);
return entryBuf;
}
SWBuf &RawCom4::getRawEntryBuf() const {
long start = 0;
unsigned long size = 0;
VerseKey *key = &getVerseKey();
findOffset(key->getTestament(), key->getTestamentIndex(), &start, &size);
entrySize = size; // support getEntrySize call
entryBuf = "";
readText(key->getTestament(), start, size, entryBuf);
rawFilter(entryBuf, 0); // hack, decipher
rawFilter(entryBuf, key);
// if (!isUnicode())
prepText(entryBuf);
return entryBuf;
}
QStringList QResourceRoot::children(int node) const
{
if(node == -1)
return QStringList();
int offset = findOffset(node) + 4; //jump past name
const short flags = (tree[offset+0] << 8) + (tree[offset+1] << 0);
offset += 2;
QStringList ret;
if(flags & Directory) {
const int child_count = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
(tree[offset+2] << 8) + (tree[offset+3] << 0);
offset += 4;
const int child_off = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
(tree[offset+2] << 8) + (tree[offset+3] << 0);
for(int i = child_off; i < child_off+child_count; ++i)
ret << name(i);
}
return ret;
}
/* inserts new buffer to end of list */
void insertToList(Node** head, char* str, int size,int offset) {
printf("\ninserting to list%s",str);
if((*head)->data==NULL) {
// *head = createHead();
printf("\ncallin createBuffer");
(*head)->data =(CharBuffer*)malloc(sizeof(CharBuffer));
(*head)->data->offset = offset;
(*head)->data->size = size;
(*head)->data->buf = (char*)malloc(sizeof(char)*size);
strcpy((*head)->data->buf,str);
// printf("value in the buffer is%s",(head)->data->buf);
printf("\nreturning from insert to list");
return;
}
// Node* new_ptr;
Node* new_ptr = (Node*)malloc(sizeof(Node));
new_ptr->next = NULL;
int offset_exists = findOffset(*head,offset,&new_ptr);
printf("\n offset_exists:%d", offset_exists);
if(offset_exists == 0) {
Node* x= *head;
/* go to the last node*/
while(x->next!=NULL)
x=x->next;
/* create a new Node*/
Node* newNode = createNode();
newNode->data=createBuffer(str, size,offset);
/* make the last node point to the newly created node*/
x->next = newNode;
return;
}
else if(offset_exists==1) {
printf("\noffset exists");
printf("\n existing offset is %s",new_ptr->data->buf);
split(new_ptr, str,offset,size);
}
}
SWBuf &HREFCom::getRawEntryBuf() const {
long start;
unsigned short size;
VerseKey *key = 0;
key = &getVerseKey();
findOffset(key->getTestament(), key->getTestamentIndex(), &start, &size);
entrySize = size; // support getEntrySize call
SWBuf tmpbuf;
readText(key->getTestament(), start, size, tmpbuf);
entryBuf = prefix;
entryBuf += tmpbuf.c_str();
prepText(entryBuf);
if (key != this->key)
delete key;
return entryBuf;
}
inline QString QResourceRoot::name(int node) const
{
if(!node) // root
return QString();
const int offset = findOffset(node);
QString ret;
int name_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
(tree[offset+2] << 8) + (tree[offset+3] << 0);
const short name_length = (names[name_offset+0] << 8) +
(names[name_offset+1] << 0);
name_offset += 2;
name_offset += 4; //jump past hash
ret.resize(name_length);
QChar *strData = ret.data();
for(int i = 0; i < name_length*2; i+=2) {
QChar c(names[name_offset+i+1], names[name_offset+i]);
*strData = c;
++strData;
}
return ret;
}
/* {{{
* common code shared by display_xyz functions to get the value from ICU
}}} */
static void get_icu_disp_value_src_php( char* tag_name, INTERNAL_FUNCTION_PARAMETERS)
{
char* loc_name = NULL;
int loc_name_len = 0;
char* disp_loc_name = NULL;
int disp_loc_name_len = 0;
UChar* disp_name = NULL;
int32_t disp_name_len = 0;
char* mod_loc_name = NULL;
int32_t buflen = 512;
UErrorCode status = U_ZERO_ERROR;
char* utf8value = NULL;
int utf8value_len = 0;
char* msg = NULL;
int grOffset = 0;
intl_error_reset( NULL TSRMLS_CC );
if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s|s",
&loc_name, &loc_name_len ,
&disp_loc_name ,&disp_loc_name_len ) == FAILURE)
{
spprintf(&msg , 0, "locale_get_display_%s : unable to parse input params", tag_name );
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, msg , 1 TSRMLS_CC );
efree(msg);
RETURN_FALSE;
}
if(loc_name_len == 0) {
loc_name = INTL_G(default_locale);
}
if( tag_name != DISP_NAME ){
/* Handle grandfathered languages */
grOffset = findOffset( LOC_GRANDFATHERED , loc_name );
if( grOffset >= 0 ){
if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
mod_loc_name = getPreferredTag( loc_name );
} else {
/* Since Grandfathered, no value, do nothing, retutn NULL */
RETURN_FALSE;
}
}
} /* end of if != LOC_CANONICAL_TAG */
if( mod_loc_name==NULL ){
mod_loc_name = estrdup( loc_name );
}
/* Get the disp_value for the given locale */
do{
disp_name = erealloc( disp_name , buflen );
disp_name_len = buflen;
/* Check if disp_loc_name passed , if not use default locale */
if( !disp_loc_name){
disp_loc_name = estrdup(INTL_G(default_locale));
}
if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
buflen = uloc_getDisplayLanguage ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , LOC_SCRIPT_TAG)==0 ){
buflen = uloc_getDisplayScript ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , LOC_REGION_TAG)==0 ){
buflen = uloc_getDisplayCountry ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , LOC_VARIANT_TAG)==0 ){
buflen = uloc_getDisplayVariant ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , DISP_NAME)==0 ){
buflen = uloc_getDisplayName ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
}
if( U_FAILURE( status ) )
{
if( status == U_BUFFER_OVERFLOW_ERROR )
{
status = U_ZERO_ERROR;
continue;
}
spprintf(&msg, 0, "locale_get_display_%s : unable to get locale %s", tag_name , tag_name );
intl_error_set( NULL, status, msg , 1 TSRMLS_CC );
efree(msg);
if( disp_name){
efree( disp_name );
}
if( mod_loc_name){
efree( mod_loc_name );
}
RETURN_FALSE;
}
} while( buflen > disp_name_len );
if( mod_loc_name){
efree( mod_loc_name );
}
/* Convert display locale name from UTF-16 to UTF-8. */
intl_convert_utf16_to_utf8( &utf8value, &utf8value_len, disp_name, buflen, &status );
efree( disp_name );
if( U_FAILURE( status ) )
{
spprintf(&msg, 0, "locale_get_display_%s :error converting display name for %s to UTF-8", tag_name , tag_name );
intl_error_set( NULL, status, msg , 1 TSRMLS_CC );
efree(msg);
RETURN_FALSE;
}
RETVAL_STRINGL( utf8value, utf8value_len , FALSE);
}
/* {{{
* Gets the value from ICU
* common code shared by get_primary_language,get_script or get_region or get_variant
* result = 0 if error, 1 if successful , -1 if no value
*/
static char* get_icu_value_internal( char* loc_name , char* tag_name, int* result , int fromParseLocale)
{
char* tag_value = NULL;
int32_t tag_value_len = 512;
int singletonPos = 0;
char* mod_loc_name = NULL;
int grOffset = 0;
int32_t buflen = 512;
UErrorCode status = U_ZERO_ERROR;
if( tag_name != LOC_CANONICALIZE_TAG ){
/* Handle grandfathered languages */
grOffset = findOffset( LOC_GRANDFATHERED , loc_name );
if( grOffset >= 0 ){
if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
tag_value = estrdup(loc_name);
return tag_value;
} else {
/* Since Grandfathered , no value , do nothing , retutn NULL */
return NULL;
}
}
if( fromParseLocale==1 ){
/* Handle singletons */
if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
if( strlen(loc_name)>1 && (isIDPrefix(loc_name) ==1 ) ){
return loc_name;
}
}
singletonPos = getSingletonPos( loc_name );
if( singletonPos == 0){
/* singleton at start of script, region , variant etc.
* or invalid singleton at start of language */
return NULL;
} else if( singletonPos > 0 ){
/* singleton at some position except at start
* strip off the singleton and rest of the loc_name */
mod_loc_name = estrndup ( loc_name , singletonPos-1);
}
} /* end of if fromParse */
} /* end of if != LOC_CANONICAL_TAG */
if( mod_loc_name == NULL){
mod_loc_name = estrdup(loc_name );
}
/* Proceed to ICU */
do{
tag_value = erealloc( tag_value , buflen );
tag_value_len = buflen;
if( strcmp(tag_name , LOC_SCRIPT_TAG)==0 ){
buflen = uloc_getScript ( mod_loc_name ,tag_value , tag_value_len , &status);
}
if( strcmp(tag_name , LOC_LANG_TAG )==0 ){
buflen = uloc_getLanguage ( mod_loc_name ,tag_value , tag_value_len , &status);
}
if( strcmp(tag_name , LOC_REGION_TAG)==0 ){
buflen = uloc_getCountry ( mod_loc_name ,tag_value , tag_value_len , &status);
}
if( strcmp(tag_name , LOC_VARIANT_TAG)==0 ){
buflen = uloc_getVariant ( mod_loc_name ,tag_value , tag_value_len , &status);
}
if( strcmp(tag_name , LOC_CANONICALIZE_TAG)==0 ){
buflen = uloc_canonicalize ( mod_loc_name ,tag_value , tag_value_len , &status);
}
if( U_FAILURE( status ) ) {
if( status == U_BUFFER_OVERFLOW_ERROR ) {
status = U_ZERO_ERROR;
continue;
}
/* Error in retriving data */
*result = 0;
if( tag_value ){
efree( tag_value );
}
if( mod_loc_name ){
efree( mod_loc_name);
}
return NULL;
}
} while( buflen > tag_value_len );
if( buflen ==0 ){
/* No value found */
*result = -1;
if( tag_value ){
efree( tag_value );
}
if( mod_loc_name ){
efree( mod_loc_name);
}
return NULL;
} else {
*result = 1;
}
if( mod_loc_name ){
efree( mod_loc_name);
}
return tag_value;
}
