const Injection* InjectionCache::getInjectionImpl(const StringData* code,
const StringData* desc) {
Unit* unit = getUnit(getStringData(code));
if (unit == NULL) {
return NULL;
}
Injection injection(unit, getStringData(desc));
const Injection* inj = getInjection(&injection);
return inj;
}
ssize_t APCArray::indexOf(const StringData* key) const {
strhash_t h = key->hash();
Bucket* b = buckets();
for (ssize_t bucket = hash()[h & m.m_capacity_mask]; bucket != -1;
bucket = b[bucket].next) {
auto kind = b[bucket].key->kind();
if (kind == APCKind::StaticString || kind == APCKind::UncountedString) {
auto const k = APCTypedValue::fromHandle(b[bucket].key);
if (key->same(k->getStringData())) {
return bucket;
}
} else if (kind == APCKind::SharedString) {
auto const k = APCString::fromHandle(b[bucket].key);
if (key->same(k->getStringData())) {
return bucket;
}
}
}
return -1;
}
UserInfo
OperationContext::getUserInfo() const
{
try
{
return UserInfo(getStringData(USER_NAME));
}
catch (ContextDataNotFoundException& e)
{
return UserInfo();
}
}
ssize_t APCArray::indexOf(const StringData* key) const {
strhash_t h = key->hash();
ssize_t bucket = hash()[h & m.m_capacity_mask];
Bucket* b = buckets();
while (bucket != -1) {
if (!isRefcountedType(b[bucket].key->type())) {
auto const k = APCTypedValue::fromHandle(b[bucket].key);
if (b[bucket].key->type() != KindOfInt64 &&
key->same(k->getStringData())) {
return bucket;
}
} else {
assert(b[bucket].key->type() == KindOfString);
auto const k = APCString::fromHandle(b[bucket].key);
if (key->same(k->getStringData())) {
return bucket;
}
}
bucket = b[bucket].next;
}
return -1;
}
void APCArray::add(APCHandle *key, APCHandle *val) {
int pos = m.m_num;
// NOTE: no check on duplication because we assume the original array has no
// duplication
Bucket* bucket = buckets() + pos;
bucket->key = key;
bucket->val = val;
m.m_num++;
int hash_pos;
if (!isRefcountedType(key->type())) {
auto const k = APCTypedValue::fromHandle(key);
hash_pos = (key->type() == KindOfInt64 ?
k->getInt64() : k->getStringData()->hash()) & m.m_capacity_mask;
} else {
assert(key->type() == KindOfString);
auto const k = APCString::fromHandle(key);
hash_pos = k->getStringData()->hash() & m.m_capacity_mask;
}
int& hp = hash()[hash_pos];
bucket->next = hp;
hp = pos;
}
inline DataType Variant::convertToNumeric(int64_t *lval, double *dval) const {
StringData *s = getStringData();
assert(s);
return s->isNumericWithVal(*lval, *dval, 1);
}
inline void toRxstring(CONSTRXSTRING &r) { r.strptr = getStringData(); r.strlength = size_v(getBLength()); } // no encoding support, so better to use blength
RexxString *extractC(sizeC_t offset, sizeC_t sublength) // Extract characters
{
return newString(getStringData() + size_v(offset), size_v(sublength), sublength); // todo m17n
}
RexxString *extractB(sizeB_t offset, sizeB_t sublength) // Extract bytes
{
return newString(getStringData() + offset, sublength);
}
RexxString *extract(size_t offset, size_t sublength) { return newString(getStringData() + offset, sublength); }
// in behaviour
RexxInteger *RexxString::caselessWordPos(RexxString *phrase, RexxInteger *pstart)
{
return StringUtil::caselessWordPos(getStringData(), getBLength(), phrase, pstart);
}
// in behaviour
RexxInteger *RexxString::wordLength(RexxInteger *position)
{
return StringUtil::wordLength(getStringData(), getBLength(), position);
}
/**
* Returns an array of all words contained in the given range
* of the string, using the same extraction rules used
* for subWord() and word().
*
* @param position The optional starting position. If not provided, extraction
* starts with the first word.
* @param plength The number of words to extract. If omitted, will extract
* from the starting postion to the end of the string.
*
* @return An array containing the extracted words. If no words are
* available within the given range, this returns an empty
* array.
*/
RexxArray *RexxString::subWords(RexxInteger *position, RexxInteger *plength)
{
return StringUtil::subWords(getStringData(), getBLength(), position, plength);
}
