bool Application::HandleConsoleCommand(const char *input)
{
int cmpres; // Used for storing string compare result
if ((cmpres = mstrcmp("broadcast",input)) == 1)
{
char* arg = new char[1024];
strcpy(arg,&(input[10]));
SmartPacket data(SMSG_SERVER_BROADCAST);
data << arg;
sSession->BroadcastPacket(&data);
sLog->StringOut("Broadcasting of message '%s' was successful!",arg);
return true;
}
else if (cmpres == 0)
{
sLog->StringOut("Usage: broadcast $message\n$message - message to be broadcast");
return true;
}
else if ((cmpres = mstrcmp("exit",input)) == 0)
{
sLog->StringOut("Exit requested from console command. Exiting...");
exit(0);
return true;
}
else if (cmpres == 1)
{
sLog->StringOut("Usage: exit\nNo arguments");
return true;
}
return false;
}
void global_map(mstr map[], mstr *beg, mstr *end)
{
mstr *left, *right, rangestart, rangeend, tmpmstr;
assert(mstrcmp(beg, end) <= 0);
for (left = map; left->addr; left++)
if (mstrcmp(left, beg) >= 0)
break;
/* left now points to the first mstr in the array that is >= beg */
for (right = left; right->addr; right++)
if (mstrcmp(right, end) > 0)
break;
/* right now points to the first mstr in the array that is > end */
if (left == right)
{ /* the usual case where {beg, end} has no or complete intersections with any existing range in map[].
* in the case of complete intersection return.
* in case of no intersection, insert {beg, end} maintaining sorted order by shifting all higher existing ranges
* two positions to the right */
if ((right - map) & 1)
return;
rangestart = *beg;
rangeend = *end;
while (left->addr)
{ /* {rangestart, rangeend} is the current range to be inserted */
tmpmstr = *left;
*left++ = rangestart;
rangestart = tmpmstr;
tmpmstr = *left;
*left++ = rangeend;
rangeend = tmpmstr;
}
*left++ = rangestart;
*left++ = rangeend;
left->addr = 0;
return;
}
/* case where {beg, end} has partial intersections with existing ranges in map[].
* replace intersecting ranges with one union range e.g. replace {1, 10} {5, 15} {12, 20} with {1, 20}
*/
if (((left - map) & 1) == 0)
*left++ = *beg;
if (((right - map) & 1) == 0)
*(--right) = *end;
if (left == right) /* possible if {beg, end} is exactly equal to an existing range in map[] */
return;
do
{
*left++ = *right;
} while ((right++)->addr);
/* note that replacing atleast 2 existing ranges with {begin, end} into one union range will cause a reduction
* in the number of ranges in map[] effectively causing higher-valued ranges on the right to shift left.
* In that case, we have to be also left-shift the null-valued mstr.addr, hence the ++ is done in the check
* for (right++)->addr in the "while" above instead of having "*left++ = *right++" in the loop.
*/
return;
}
Player* Session::GetPlayerByName(const char* name)
{
if (!name)
return NULL;
for (std::list<Player*>::iterator itr = clientList.begin(); itr != clientList.end(); ++itr)
{
if (mstrcmp((*itr)->m_nickName.c_str(), name) == 0)
return (*itr);
}
return NULL;
}
/* $GPGGA
* $GPGGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*hh
* ex: $GPGGA,230600.501,4543.8895,N,02112.7238,E,1,03,3.3,96.7,M,39.0,M,,0000*6A,
*
* WORDS:
* 1 = UTC of Position
* 2 = Latitude
* 3 = N or S
* 4 = Longitude
* 5 = E or W
* 6 = GPS quality indicator (0=invalid; 1=GPS fix; 2=Diff. GPS fix)
* 7 = Number of satellites in use [not those in view]
* 8 = Horizontal dilution of position
* 9 = Antenna altitude above/below mean sea level (geoid)
* 10 = Meters (Antenna height unit)
* 11 = Geoidal separation (Diff. between WGS-84 earth ellipsoid and mean sea level.
* -geoid is below WGS-84 ellipsoid)
* 12 = Meters (Units of geoidal separation)
* 13 = Age in seconds since last update from diff. reference station
* 14 = Diff. reference station ID#
* 15 = Checksum
*/
void nmea_parse_gpgga()
{
if (mstrcmp(words[0], "$GPGGA") == 0) {
if(words[6][0] == '0') {
latitude = 0;
longtitude = 0;
flagDataReady = 0;
}
//parse GPS data
flagDataReady = 1;
}
}
/*-------------------------------------------------------------------------*/
static wiz_list_t *
find_wiz (string_t *name)
/* Find the entry for the user 'name' and return it's pointer.
* Return NULL if it can't be found.
*/
{
wiz_list_t *wl;
if ( !( name = find_tabled(name) ) )
return NULL;
for (wl = all_wiz; wl; wl = wl->next)
{
int rc = mstrcmp(wl->name, name);
if (!rc)
return wl;
if (rc > 0)
break;
}
return NULL;
} /* find_wiz() */
/*
* parse internal tmp_ structures, fused by pushdata, and set the data flag when done
*/
void NMEA::parsedata() {
int received_cks = 16*digit2dec(tmp_szChecksum[0]) + digit2dec(tmp_szChecksum[1]);
//uart1.Send("seq: [cc:%X][words:%d][rc:%s:%d]\r\n", m_nChecksum,m_nWordIdx, tmp_szChecksum, received_cks);
// check checksum, and return if invalid!
if (m_nChecksum != received_cks) {
//m_bFlagDataReady = false;
return;
}
/* $GPGGA
* $GPGGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*hh
* ex: $GPGGA,230600.501,4543.8895,N,02112.7238,E,1,03,3.3,96.7,M,39.0,M,,0000*6A,
*
* WORDS:
* 1 = UTC of Position
* 2 = Latitude
* 3 = N or S
* 4 = Longitude
* 5 = E or W
* 6 = GPS quality indicator (0=invalid; 1=GPS fix; 2=Diff. GPS fix)
* 7 = Number of satellites in use [not those in view]
* 8 = Horizontal dilution of position
* 9 = Antenna altitude above/below mean sea level (geoid)
* 10 = Meters (Antenna height unit)
* 11 = Geoidal separation (Diff. between WGS-84 earth ellipsoid and mean sea level.
* -geoid is below WGS-84 ellipsoid)
* 12 = Meters (Units of geoidal separation)
* 13 = Age in seconds since last update from diff. reference station
* 14 = Diff. reference station ID#
* 15 = Checksum
*/
if (mstrcmp(tmp_words[0], "$GPGGA") == 0) {
// Check GPS Fix: 0=no fix, 1=GPS fix, 2=Dif. GPS fix
if (tmp_words[6][0] == '0') {
// clear data
res_fLatitude = 0;
res_fLongitude = 0;
m_bFlagDataReady = false;
return;
}
// parse time
res_nUTCHour = digit2dec(tmp_words[1][0]) * 10 + digit2dec(tmp_words[1][1]);
res_nUTCMin = digit2dec(tmp_words[1][2]) * 10 + digit2dec(tmp_words[1][3]);
res_nUTCSec = digit2dec(tmp_words[1][4]) * 10 + digit2dec(tmp_words[1][5]);
// parse latitude and longitude in NMEA format
res_fLatitude = string2float(tmp_words[2]);
res_fLongitude = string2float(tmp_words[4]);
// get decimal format
if (tmp_words[3][0] == 'S') res_fLatitude *= -1.0;
if (tmp_words[5][0] == 'W') res_fLongitude *= -1.0;
float degrees = trunc(res_fLatitude / 100.0f);
float minutes = res_fLatitude - (degrees * 100.0f);
res_fLatitude = degrees + minutes / 60.0f;
degrees = trunc(res_fLongitude / 100.0f);
minutes = res_fLongitude - (degrees * 100.0f);
res_fLongitude = degrees + minutes / 60.0f;
// parse number of satellites
res_nSatellitesUsed = (int)string2float(tmp_words[7]);
// parse altitude
res_fAltitude = string2float(tmp_words[9]);
// data ready
m_bFlagDataReady = true;
}
/* $GPRMC
* note: a siRF chipset will not support magnetic headers.
* $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a*hh
* ex: $GPRMC,230558.501,A,4543.8901,N,02112.7219,E,1.50,181.47,230213,,,A*66,
*
* WORDS:
* 1 = UTC of position fix
* 2 = Data status (V=navigation receiver warning)
* 3 = Latitude of fix
* 4 = N or S
* 5 = Longitude of fix
* 6 = E or W
* 7 = Speed over ground in knots
* 8 = Track made good in degrees True, Bearing This indicates the direction that the device is currently moving in,
* from 0 to 360, measured in “azimuth”.
* 9 = UT date
* 10 = Magnetic variation degrees (Easterly var. subtracts from true course)
* 11 = E or W
* 12 = Checksum
*/
if (mstrcmp(tmp_words[0], "$GPRMC") == 0) {
// Check data status: A-ok, V-invalid
if (tmp_words[2][0] == 'V') {
// clear data
res_fLatitude = 0;
res_fLongitude = 0;
m_bFlagDataReady = false;
return;
}
// parse time
res_nUTCHour = digit2dec(tmp_words[1][0]) * 10 + digit2dec(tmp_words[1][1]);
res_nUTCMin = digit2dec(tmp_words[1][2]) * 10 + digit2dec(tmp_words[1][3]);
res_nUTCSec = digit2dec(tmp_words[1][4]) * 10 + digit2dec(tmp_words[1][5]);
// parse latitude and longitude in NMEA format
res_fLatitude = string2float(tmp_words[3]);
res_fLongitude = string2float(tmp_words[5]);
// get decimal format
if (tmp_words[4][0] == 'S') res_fLatitude *= -1.0;
if (tmp_words[6][0] == 'W') res_fLongitude *= -1.0;
float degrees = trunc(res_fLatitude / 100.0f);
float minutes = res_fLatitude - (degrees * 100.0f);
res_fLatitude = degrees + minutes / 60.0f;
degrees = trunc(res_fLongitude / 100.0f);
minutes = res_fLongitude - (degrees * 100.0f);
res_fLongitude = degrees + minutes / 60.0f;
//parse speed
// The knot (pronounced not) is a unit of speed equal to one nautical mile (1.852 km) per hour
res_fSpeed = string2float(tmp_words[7]);
res_fSpeed *= 1.852; // convert to km/h
// parse bearing
res_fBearing = string2float(tmp_words[8]);
// parse UTC date
res_nUTCDay = digit2dec(tmp_words[9][0]) * 10 + digit2dec(tmp_words[9][1]);
res_nUTCMonth = digit2dec(tmp_words[9][2]) * 10 + digit2dec(tmp_words[9][3]);
res_nUTCYear = digit2dec(tmp_words[9][4]) * 10 + digit2dec(tmp_words[9][5]);
// data ready
m_bFlagDataReady = true;
}
}
void gv_select(char *cli_buff, int n_len, boolean_t freeze, char opname[], glist *gl_head,
int *reg_max_rec, int *reg_max_key, int *reg_max_blk)
{
bool stashed = FALSE;
int num_quote, len, gmap_size, new_gmap_size, estimated_entries, count;
char *ptr, *ptr1, *c;
mstr gmap[512], *gmap_ptr, *gmap_ptr_base, gmap_beg, gmap_end;
mval val, curr_gbl_name;
glist *gl_tail, *gl_ptr;
#ifdef GTM64
hash_table_int8 ext_hash;
ht_ent_int8 *tabent;
#else
hash_table_int4 ext_hash;
ht_ent_int4 *tabent;
#endif /* GTM64 */
error_def(ERR_FREEZE);
error_def(ERR_DBRDONLY);
error_def(ERR_SELECTSYNTAX);
error_def(ERR_MUNOFINISH);
error_def(ERR_MUNOACTION);
error_def(ERR_FREEZECTRL);
memset(gmap, 0, sizeof(gmap));
gmap_size = sizeof(gmap) / sizeof(gmap[0]);
gmap_ptr_base = &gmap[0];
/* "estimated_entries" is a conservative estimate of the # of entries that could be used up in the gmap array */
estimated_entries = 1; /* take into account the NULL gmap entry at the end of the array */
for (ptr = cli_buff; *ptr; ptr = ptr1)
{
for (ptr1 = ptr; ; ptr1++)
{
if (',' == *ptr1)
{
len = (int)(ptr1 - ptr);
ptr1++;
break;
} else if (!*ptr1)
{
len = (int)(ptr1 - ptr);
break;
}
}
gmap_beg.addr = ptr;
c = gmap_beg.addr + len - 1;
num_quote = 0;
while ('"' == *c)
{
len--;
c--;
num_quote++;
}
if (0 >= len)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
c = gmap_beg.addr;
while (0 < num_quote)
{
if ('"' == *c)
{
c++;
len--;
} else
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
num_quote--;
}
gmap_beg.addr = c;
if ('^' == *c)
{
gmap_beg.addr++;
len--;
}
gmap_beg.len = len;
c = mu_extr_ident(&gmap_beg);
len -= (c - gmap_beg.addr);
assert(len >= 0);
if (0 == len)
gmap_end = gmap_beg;
else if (gmap_beg.len == 1 && '*' == *c)
{
gmap_beg.addr = (char*)&percent_lit;
gmap_beg.len = sizeof(percent_lit);
gmap_end.addr = (char*)&tilde_lit;
gmap_end.len = sizeof(tilde_lit);
} else if (1 == len && '*' == *c)
{
gmap_end = gmap_beg;
gmap_beg.len--;
*c = '~';
} else if (':' != *c)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
} else
{
gmap_beg.len = INTCAST(c - gmap_beg.addr);
c++;
gmap_end.addr = c;
gmap_end.len = len - 1;
if ('^' == *c)
{
gmap_end.addr++;
gmap_end.len--;
}
c = mu_extr_ident(&gmap_end);
if (c - gmap_end.addr != gmap_end.len || mstrcmp(&gmap_beg, &gmap_end) > 0)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
}
/* "estimated_entries" is the maximum number of entries that could be used up in the gmap array including the
* next global_map call. The actual number of used entries could be much lower than this.
* But since determining the actual number would mean scanning the gmap array for the first NULL pointer (a
* performance overhead), we do an approximate check instead.
*/
estimated_entries += MAX_GMAP_ENTRIES_PER_ITER;
if (estimated_entries >= gmap_size)
{ /* Current gmap array does not have enough space. Double size before calling global_map */
new_gmap_size = gmap_size * 2; /* double size of gmap array */
gmap_ptr = (mstr *)malloc(sizeof(mstr) * new_gmap_size);
memcpy(gmap_ptr, gmap_ptr_base, sizeof(mstr) * gmap_size);
if (gmap_ptr_base != &gmap[0])
free(gmap_ptr_base);
gmap_size = new_gmap_size;
gmap_ptr_base = gmap_ptr;
}
global_map(gmap_ptr_base, &gmap_beg, &gmap_end);
DEBUG_ONLY(
count = 1;
for (gmap_ptr = gmap_ptr_base; gmap_ptr->addr; gmap_ptr++)
count++;
assert(count < gmap_size);
)
}
if (freeze)
{
GTM64_ONLY(init_hashtab_int8(&ext_hash, 0);)
NON_GTM64_ONLY(init_hashtab_int4(&ext_hash, 0);)
}
/*-------------------------------------------------------------------------*/
wiz_list_t *
add_name (string_t * str)
/* Check if an entry for wizard <str> exists; add it, if it doesn't.
* Return the pointer to the wiz_list entry.
* Must not change refcount of <str>.
*/
{
wiz_list_t *wl;
wiz_list_t *prev, *this;
wl = find_wiz(str);
if (wl)
return wl;
number_of_wiz++;
wl = xalloc(sizeof (wiz_list_t));
str = make_tabled_from(str);
wl->next = NULL;
wl->name = str;
wl->score = 0;
wl->cost = 0;
wl->gigacost = 0;
wl->total_cost = 0;
wl->total_gigacost = 0;
wl->heart_beats = 0;
wl->size_array = 0;
wl->mapping_total = 0;
#ifdef USE_STRUCTS
wl->struct_total = 0;
#endif /* USE_STRUCTS */
#if 0
wl->quota_allowance = 0;
wl->quota_usage = 0;
#endif
wl->file_name = NULL;
wl->error_message = NULL;
if (wiz_info_extra_size >= 0)
put_array(&(wl->extra), allocate_array(wiz_info_extra_size));
else
wl->extra = const0;
wl->last_call_out = 0;
/* Find the insertion point and insert the new entry */
for ( prev = NULL, this = all_wiz
; this && mstrcmp(this->name, str) < 0
; prev = this, this = this->next
)
{ NOOP; }
if (!prev)
{
wl->next = all_wiz;
all_wiz = wl;
}
else
{
wl->next = this;
prev->next = wl;
}
return wl;
} /* add_name() */
void gv_select(char *cli_buff, int n_len, boolean_t freeze, char opname[], glist *gl_head,
int *reg_max_rec, int *reg_max_key, int *reg_max_blk)
{
bool stashed = FALSE;
int num_quote, len;
char *ptr, *ptr1, *c;
mstr gmap[256], *gmap_ptr, gmap_beg, gmap_end;
mval val, curr_gbl_name;
glist *gl_tail, *gl_ptr;
htab_desc *ext_hash;
mname ht_mname;
ht_entry *h;
error_def(ERR_FREEZE);
error_def(ERR_DBRDONLY);
error_def(ERR_SELECTSYNTAX);
error_def(ERR_MUNOFINISH);
error_def(ERR_MUNOACTION);
memset(gmap, 0, sizeof(gmap));
for (ptr = cli_buff; *ptr; ptr = ptr1)
{
for (ptr1 = ptr; ; ptr1++)
{
if (',' == *ptr1)
{
len = ptr1 - ptr;
ptr1++;
break;
}
else if (!*ptr1)
{
len = ptr1 - ptr;
break;
}
}
gmap_beg.addr = ptr;
c = gmap_beg.addr + len - 1;
num_quote = 0;
while ('"' == *c)
{
len--;
c--;
num_quote++;
}
if (0 >= len)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
c = gmap_beg.addr;
while (0 < num_quote)
{
if ('"' == *c)
{
c++;
len--;
}
else
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
num_quote--;
}
gmap_beg.addr = c;
if ('^' == *c)
{
gmap_beg.addr++;
len--;
}
gmap_beg.len = len;
c = mu_extr_ident(&gmap_beg);
len -= (c - gmap_beg.addr);
assert(len >= 0);
if (0 == len)
gmap_end = gmap_beg;
else if (gmap_beg.len == 1 && '*' == *c)
{
gmap_beg.addr = (char*)&percent_lit;
gmap_beg.len = sizeof(percent_lit);
gmap_end.addr = (char*)&tilde_lit;
gmap_end.len = sizeof(tilde_lit);
}
else if (1 == len && '*' == *c)
{
gmap_end = gmap_beg;
gmap_beg.len--;
*c = '~';
}
else if (':' != *c)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
else
{
gmap_beg.len = c - gmap_beg.addr;
c++;
gmap_end.addr = c;
gmap_end.len = len - 1;
if ('^' == *c)
{
gmap_end.addr++;
gmap_end.len--;
}
c = mu_extr_ident(&gmap_end);
if (c - gmap_end.addr != gmap_end.len || mstrcmp(&gmap_beg, &gmap_end) > 0)
{
gtm_putmsg(VARLSTCNT(4) ERR_SELECTSYNTAX, 2, LEN_AND_STR(opname));
mupip_exit(ERR_MUNOACTION);
}
}
global_map(gmap, &gmap_beg, &gmap_end);
}
if (freeze)
{
ext_hash = (htab_desc *)malloc(sizeof(htab_desc));
ht_init(ext_hash, 0);
memset(&ht_mname.txt[0], 0, sizeof(mname));
}
gl_head->next = NULL;
gl_tail = gl_head;
*reg_max_rec = 0;
*reg_max_key = 0;
*reg_max_blk = 0;
for (gmap_ptr = gmap; gmap_ptr->addr ; gmap_ptr++)
{
curr_gbl_name.mvtype = MV_STR;
curr_gbl_name.str = *gmap_ptr++;
op_gvname(VARLSTCNT(1) &curr_gbl_name);
if (dba_cm == gv_cur_region->dyn.addr->acc_meth)
{ util_out_print("Can not select globals from region !AD across network",TRUE,gv_cur_region->rname_len,
gv_cur_region->rname);
mupip_exit(ERR_MUNOFINISH);
}
if (dba_bg != gv_cur_region->dyn.addr->acc_meth && dba_mm != gv_cur_region->dyn.addr->acc_meth)
{
assert(gv_cur_region->dyn.addr->acc_meth == dba_usr);
util_out_print("Can not select globals from non-GTC region !AD",TRUE,gv_cur_region->rname_len,
gv_cur_region->rname);
mupip_exit(ERR_MUNOFINISH);
}
op_gvdata(&val);
if (0 == val.m[1])
{
op_gvname(VARLSTCNT(1) &curr_gbl_name);
op_gvorder(&curr_gbl_name);
if (!curr_gbl_name.str.len)
break;
assert('^' == *curr_gbl_name.str.addr);
curr_gbl_name.str.addr++;
curr_gbl_name.str.len--;
}
for (;;)
{
if (mstrcmp(&curr_gbl_name.str, gmap_ptr) > 0)
break;
if (freeze)
{
memcpy(&ht_mname.txt[0], &gv_cur_region, sizeof(int4));
h = ht_put(ext_hash, &ht_mname, &stashed);
if (stashed)
{
if (cs_addrs->hdr->freeze)
{
gtm_putmsg(VARLSTCNT(4) ERR_FREEZE, 2, gv_cur_region->rname_len,
gv_cur_region->rname);
mupip_exit(ERR_MUNOFINISH);
}
/* Cannot proceed for read-only data files */
if (gv_cur_region->read_only)
{
util_out_print("Cannot freeze the database",TRUE);
gtm_putmsg(VARLSTCNT(4) ERR_DBRDONLY, 2,
DB_LEN_STR(gv_cur_region));
mupip_exit(ERR_MUNOFINISH);
}
while (FALSE == region_freeze(gv_cur_region, TRUE, FALSE))
hiber_start(1000);
wcs_flu(WCSFLU_FLUSH_HDR | WCSFLU_WRITE_EPOCH | WCSFLU_SYNC_EPOCH);
}
}
assert(curr_gbl_name.str.len > 0);
gl_ptr = (glist*)malloc(sizeof(glist) - 1 + curr_gbl_name.str.len);
gl_ptr->name.mvtype = MV_STR;
gl_ptr->name.str.addr = (char*)gl_ptr->nbuf;
gl_ptr->name.str.len = curr_gbl_name.str.len;
memcpy(gl_ptr->nbuf, curr_gbl_name.str.addr, curr_gbl_name.str.len);
gl_ptr->next = 0;
gl_tail->next = gl_ptr;
gl_tail = gl_ptr;
if (*reg_max_rec < cs_data->max_rec_size) *reg_max_rec = cs_data->max_rec_size;
if (*reg_max_key < cs_data->max_key_size) *reg_max_key = cs_data->max_key_size;
if (*reg_max_blk < cs_data->blk_size) *reg_max_blk = cs_data->blk_size;
op_gvname(VARLSTCNT(1) &gl_tail->name);
op_gvorder(&curr_gbl_name);
if (0 == curr_gbl_name.str.len)
{
(gmap_ptr + 1)->addr = 0;
break;
}
assert('^' == *curr_gbl_name.str.addr);
curr_gbl_name.str.addr++;
curr_gbl_name.str.len--;
}
}
}
