Minus = ct.widen('-');
pow_e = ct.widen('e');
pow_E = ct.widen('E');
const uint64 low_mask = ULL(0xffffffff);
const uint64 u0 = u & low_mask;
const uint64 u1 = u >> 32;
const uint64 v0 = v & low_mask;
const uint64 v1 = v >> 32;
uint64 t = u0 * v0;
low = t & low_mask;
t = u1 * v0 + (t >> 32);
uint64 w1 = t & low_mask;
uint64 w2 = t >> 32;
int count, U8CPU alpha) {
SkASSERT(alpha <= 255);
if (count <= 0) {
return;
uint32_t src_scale = SkAlpha255To256(alpha);
uint32_t dst_scale = 256 - src_scale;
if (count >= 4) {
SkASSERT(((size_t)dst & 0x03) == 0);
while (((size_t)dst & 0x0F) != 0) {
*dst = SkAlphaMulQ(*src, src_scale) + SkAlphaMulQ(*dst, dst_scale);
__m128i dst_scale_wide = _mm_set1_epi16(dst_scale << 8);
while (count >= 4) {
// Load 4 pixels each of src and dest.
pow_e = ct.widen('e');
pow_E = ct.widen('E');
ct.widen(ndigits + 0, ndigits + 10, digits);
uint64& high, uint64& low) {
const uint64 low_mask = ULL(0xffffffff);
const uint64 u0 = u & low_mask;
const uint64 u1 = u >> 32;
const uint64 v0 = v & low_mask;
const uint64 v1 = v >> 32;
uint64 t = u0 * v0;
low = t & low_mask;
t = u1 * v0 + (t >> 32);
uint64 w1 = t & low_mask;
uint64 w2 = t >> 32;
count = dcmap->num_colors;
s = (UBYTE *)(scmap->ctab);
d = (UBYTE *)(dcmap->ctab);
vp = q - p;
q2 = q/2;
while (--count >= 0)
{
*d++ = ((*s++ * vp) + ((UBYTE)(color->r) * p) + q2)/q;
*d++ = ((*s++ * vp) + ((UBYTE)(color->g) * p) + q2)/q;
*d++ = ((*s++ * vp) + ((UBYTE)(color->b) * p) + q2)/q;
}
{
color = &pcb.in_from;
pp = ¬done;
const void* SK_RESTRICT src, int n) {
SkASSERT(n > 0 && n <= 15);
uint8_t* d = (uint8_t*)dst;
switch (n) {
case 15: *d++ = *s++;
case 14: *d++ = *s++;
case 13: *d++ = *s++;
case 12: *d++ = *s++;
case 11: *d++ = *s++;
case 10: *d++ = *s++;
case 9: *d++ = *s++;
case 8: *d++ = *s++;
case 7: *d++ = *s++;
case 6: *d++ = *s++;
case 5: *d++ = *s++;
case 4: *d++ = *s++;
case 3: *d++ = *s++;
const void* SK_RESTRICT src, int n) {
SkASSERT(n > 0 && n <= 15);
uint8_t* d = (uint8_t*)dst;
switch (n) {
case 15: *d++ = *s++;
case 14: *d++ = *s++;
case 13: *d++ = *s++;
case 12: *d++ = *s++;
case 11: *d++ = *s++;
case 10: *d++ = *s++;
case 9: *d++ = *s++;
case 8: *d++ = *s++;
case 7: *d++ = *s++;
case 6: *d++ = *s++;
case 5: *d++ = *s++;
case 4: *d++ = *s++;
case 3: *d++ = *s++;
{
wchar_t *save = destination;
for (; *destination; ++destination);
while ((*destination++ = *source++));
for (; *string ; ++string)
if (*string == c)
{
while (*string1 == *string2++)
if (*string1++ == 0)
return (0);
{
wchar_t *save = destination;
{
const wchar_t *scan1 = s;
const wchar_t *scan2 = t;
// limitations under the License.
// ========================================================================
SELECTANY byte spaces[256] = {
const TCHAR* const kFalse = _T("false");
const TCHAR* const kTrue = _T("true");
if (c < 256)
return (c == 133 || IsSpaceA((char) (c & 0xff)));
return (c >= 8192 && c <= 8203) || c == 8232 ||
c == 8233 || c == 12288;
}
bool IsSpaceA(char c) {
return spaces[static_cast<unsigned char>(c)] == 1;
#define isnan(x) \
( sizeof (x) == sizeof(float ) ? __inline_isnanf((float)(x)) \
: sizeof (x) == sizeof(double) ? __inline_isnand((double)(x)) \
: __inline_isnan ((long double)(x)))
#define isinf(x) \
( sizeof (x) == sizeof(float ) ? __inline_isinff((float)(x)) \
: sizeof (x) == sizeof(double) ? __inline_isinfd((double)(x)) \
: __inline_isinf ((long double)(x)))
bool string_substr_check(int len, int &f, int &l, bool strict /* = true */) {
if (f < 0) {
f += len;
}
if (f > len || f == len && strict) {
if (l < 0) {
l += len - f;
{
QByteArray constructorName = className();
{
int idx = constructorName.lastIndexOf(':');
if (idx != -1)
constructorName.remove(0, idx+1); // remove qualified part
enum { MaximumParamCount = 10 };
const char *typeNames[] = {val0.name(), val1.name(), val2.name(), val3.name(), val4.name(),
val5.name(), val6.name(), val7.name(), val8.name(), val9.name()};
int paramCount;
for (paramCount = 0; paramCount < MaximumParamCount; ++paramCount) {
int len = qstrlen(typeNames[paramCount]);
if (len <= 0)
break;
daeAtomicTypeArray* daeAtomicType::_Types = NULL;
daeBool daeAtomicType::_TypesInitialized = false;
{
_Types = new daeAtomicTypeArray;
//mandatory to set here, because the array types are querying the atomic types
_TypesInitialized = true;
{
_TypesInitialized = false;
unsigned int i;
for (i=0;i<_Types->getCount();i++)
{
daeAtomicType* type = _Types->get(i);
int tCount = (int)_Types->getCount();
int i;
void reconfigure(const SkImageInfo& newInfo, size_t rowBytes, SkColorTable* ctable) {
if (kIndex_8_SkColorType != newInfo.colorType()) {
ctable = nullptr;
}
mRowBytes = rowBytes;
if (mColorTable != ctable) {
SkSafeUnref(mColorTable);
mColorTable = ctable;
// feasible without going insane trying to figure it out
SkImageInfo* myInfo = const_cast<SkImageInfo*>(&this->info());
*myInfo = newInfo;
changeAlphaType(alphaType);
void setHasHardwareMipMap(bool hasMipMap) {
mHasHardwareMipMap = hasMipMap;
env->GetJavaVM(&mPixelStorage.java.jvm);
mPixelStorage.java.jweakRef = env->NewWeakGlobalRef(storageObj);
{
node = new Node( "." );
rootNode = new RootNode( this, root, vendor, application );
}
{
node = new Node( "." );
rootNode = new RootNode( this, path, vendor, application );
* return the number of groups that are contained within a group
* example: int n = base.groups();
* - the index must be within the range given by groups()
* example: printf( "Group(%d)='%s'\n", ix, base.group(ix) );
{
Node *nd = node->search( key );
* return the number of entries (name/value) pairs for a group
* example: int n = buttonColor.entries();
* - the index must be within the range given by entries()
* example: printf( "Entry(%d)='%s'\n", ix, buttonColor.entry(ix) );