dl_error_t dl_internal_convert_no_header( dl_ctx_t dl_ctx,
unsigned char* packed_instance, unsigned char* packed_instance_base,
unsigned char* out_instance, size_t out_instance_size,
size_t* needed_size,
dl_endian_t src_endian, dl_endian_t out_endian,
dl_ptr_size_t src_ptr_size, dl_ptr_size_t out_ptr_size,
const SDLType* root_type, size_t base_offset )
{
dl_binary_writer writer;
dl_binary_writer_init( &writer, out_instance, out_instance_size, out_instance == 0x0, src_endian, out_endian, out_ptr_size );
SConvertContext ConvCtx( src_endian, out_endian, src_ptr_size, out_ptr_size );
ConvCtx.m_lInstances.Add(SInstance(packed_instance, root_type, 0x0, dl_type_t(DL_TYPE_ATOM_POD | DL_TYPE_STORAGE_STRUCT)));
dl_error_t err = dl_internal_convert_collect_instances(dl_ctx, root_type, packed_instance, packed_instance_base, ConvCtx);
// TODO: we need to sort the instances here after their offset!
SInstance* insts = ConvCtx.m_lInstances.GetBasePtr();
std::sort( insts, insts + ConvCtx.m_lInstances.Len(), dl_internal_sort_pred );
for(unsigned int i = 0; i < ConvCtx.m_lInstances.Len(); ++i)
{
err = dl_internal_convert_write_instance( dl_ctx, ConvCtx.m_lInstances[i], &ConvCtx.m_lInstances[i].m_OffsetAfterPatch, ConvCtx, &writer );
if(err != DL_ERROR_OK)
return err;
}
if(out_instance != 0x0) // no need to patch data if we are only calculating size
{
for(unsigned int i = 0; i < ConvCtx.m_lPatchOffset.Len(); ++i)
{
SConvertContext::PatchPos& PP = ConvCtx.m_lPatchOffset[i];
// find new offset
pint NewOffset = pint(-1);
for(unsigned int j = 0; j < ConvCtx.m_lInstances.Len(); ++j )
{
pint OldOffset = ConvCtx.m_lInstances[j].m_pAddress - packed_instance_base;
if(OldOffset == PP.m_OldOffset)
{
NewOffset = ConvCtx.m_lInstances[j].m_OffsetAfterPatch;
break;
}
}
DL_ASSERT(NewOffset != pint(-1) && "We should have found the instance!");
dl_binary_writer_seek_set( &writer, PP.m_Pos );
dl_binary_writer_write_ptr( &writer, NewOffset + base_offset );
}
}
dl_binary_writer_seek_end( &writer );
*needed_size = (unsigned int)dl_binary_writer_tell( &writer );
return err;
}
static dl_error_t dl_internal_load_type_library_defaults(dl_ctx_t dl_ctx, unsigned int first_new_type, const uint8* default_data, unsigned int default_data_size)
{
if( default_data_size == 0 ) return DL_ERROR_OK;
if( dl_ctx->default_data != 0x0 )
return DL_ERROR_OUT_OF_DEFAULT_VALUE_SLOTS;
dl_ctx->default_data = (uint8*)dl_ctx->alloc_func( default_data_size * 2, sizeof(void*), dl_ctx->alloc_ctx ); // TODO: times 2 here need to be fixed!
uint8* dst = dl_ctx->default_data;
// ptr-patch and convert to native
for( unsigned int type_index = first_new_type; type_index < dl_ctx->type_count; ++type_index )
{
union
{
const uint8* data_ptr;
const SDLType* type_ptr;
} ptr_conv;
ptr_conv.data_ptr = dl_ctx->type_info_data + dl_ctx->type_lookup[type_index].offset;
for( unsigned int member_index = 0; member_index < ptr_conv.type_ptr->member_count; ++member_index )
{
SDLMember* member = (SDLMember*)ptr_conv.type_ptr->members + member_index;
if( member->default_value_offset == DL_UINT32_MAX )
continue;
dst = dl_internal_align_up( dst, member->alignment[DL_PTR_SIZE_HOST] );
uint8* src = (uint8*)default_data + member->default_value_offset;
pint base_offset = pint( dst ) - pint( dl_ctx->default_data );
member->default_value_offset = uint32( base_offset );
dl_one_member_type dummy( member );
size_t needed_size;
union
{
dl_one_member_type* one_mem_ptr;
SDLType* type_ptr;
} conv;
conv.one_mem_ptr = &dummy;
dl_internal_convert_no_header( dl_ctx,
src, (unsigned char*)default_data,
dst, 1337, // need to check this size ;) Should be the remainder of space in m_pDefaultInstances.
&needed_size,
DL_ENDIAN_LITTLE, DL_ENDIAN_HOST,
DL_PTR_SIZE_32BIT, DL_PTR_SIZE_HOST,
conv.type_ptr, base_offset );
SPatchedInstances patch_instances;
dl_internal_patch_loaded_ptrs( dl_ctx, &patch_instances, dst, conv.type_ptr, dl_ctx->default_data, false );
dst += needed_size;
}
}
return DL_ERROR_OK;
}
pint FindWrittenPtr( void* ptr )
{
for( pint i = 0; i < m_WrittenPtrs.Len(); ++i )
if( m_WrittenPtrs[i].ptr == ptr )
return m_WrittenPtrs[i].pos;
return pint(-1);
}
int
main(int argc, char *argv[])
{
#define p(m, v, fmt) printf(".ds %s " fmt "\n", m, v)
#define pstr(m) p(#m, m, "%s")
#define pint(m) p(#m, m, "%d")
pstr(AUFS_VERSION);
pstr(AUFS_XINO_FNAME);
pstr(AUFS_XINO_DEFPATH);
pint(AUFS_DIRWH_DEF);
pstr(AUFS_WH_PFX);
pstr(AUFS_WKQ_NAME);
pint(AUFS_NWKQ_DEF);
pstr(AUFS_WH_DIROPQ);
pstr(AUFS_WH_BASENAME);
pstr(AUFS_WH_PLINKDIR);
pint(AUFS_BRANCH_MAX);
return 0;
}
int
main(int argc, char *argv[])
{
#define p(m, v, fmt) printf("%s=" fmt "\n", m, v)
#define pstr(m) p(#m, m, "%s")
#define pint(m) p(#m, m, "%d")
pstr(AUFS_VERSION);
pint(AUFS_SUPER_MAGIC);
printf("AUFS_SUPER_MAGIC_HEX=0x%x\n", AUFS_SUPER_MAGIC);
pstr(AUFS_WH_PFX);
pstr(AUFS_WH_PFX2);
pint(AUFS_MAX_NAMELEN);
pstr(AUFS_WKQ_NAME);
pstr(AUFS_WH_DIROPQ);
pstr(AUFS_WH_BASE);
pstr(AUFS_WH_PLINKDIR);
pstr(AUFS_WH_ORPHDIR);
//pint(AUFS_BRANCH_MAX);
return 0;
}
int main(int argc, char *argv[])
{
int n = gint(), i, x, y;
long long int a[2020], dp[2020];
for (i = 0; i < n; ++i){
a[i] = gint();
dp[i] = a[i] * n;
}
for (x = n - 1; x > 0; --x)
for(y = 0; y < x; ++y)
dp[y] = (((dp[y] + x*a[y + n - x]) > (dp[y + 1] + x*a[y])) ? (dp[y] + x*a[y + n - x]) : (dp[y + 1] + x*a[y]));
pint(dp[0]);
return 0;
}
int main(int argc, char *argv[])
{
int primes[168] = {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,
421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,
613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997
};
int t = gint();
int i, a, b, gcd, ans, tmp;
while(t--){
a = gint();
b = gint();
gcd = euclid_gcd(a, b);
ans = 1;
for (i = 0; i < 168; ++i)
{
if (gcd <= 1)
break;
tmp = 0;
while(!(gcd % primes[i])){
gcd /= primes[i];
tmp++;
}
ans *= tmp + 1;
}
if(gcd > 1)
ans *= 2;
pint(ans);
putchar_unlocked('\n');
}
return 0;
}
static int
p_seprint(Msg *m)
{
int i, n, code;
uint8_t *o, *ps;
char *p, *e;
char msg[64];
/* no next proto */
m->pr = nil;
p = m->p;
e = m->e;
ps = m->ps;
while(ps < m->pe){
code = *ps++;
if(code == 255)
break;
if(code == 0)
continue;
/* ignore anything that's too long */
n = *ps++;
o = ps;
ps += n;
if(ps > m->pe)
break;
switch(code){
case ODipaddr: /* requested ip address */
p = pserver(p, e, "ipaddr", o, n);
break;
case ODlease: /* requested lease time */
p = pint(p, e, "lease", o, n);
break;
case ODtype:
p = ptype(p, e, *o);
break;
case ODserverid:
p = pserver(p, e, "serverid", o, n);
break;
case ODmessage:
p = pstring(p, e, "message", o, n);
break;
case ODmaxmsg:
p = puint(p, e, "maxmsg", o, n);
break;
case ODclientid:
p = phex(p, e, "clientid", o, n);
break;
case ODparams:
p = seprint(p, e, " requested=(");
for(i = 0; i < n; i++){
if(i != 0)
p = seprint(p, e, " ");
p = seprint(p, e, "%ud", o[i]);
}
p = seprint(p, e, ")");
break;
case ODvendorclass:
p = pstring(p, e, "vendorclass", o, n);
break;
case OBmask:
p = pserver(p, e, "mask", o, n);
break;
case OBtimeoff:
p = pint(p, e, "timeoff", o, n);
break;
case OBrouter:
p = pserver(p, e, "router", o, n);
break;
case OBtimeserver:
p = pserver(p, e, "timesrv", o, n);
break;
case OBnameserver:
p = pserver(p, e, "namesrv", o, n);
break;
case OBdnserver:
p = pserver(p, e, "dnssrv", o, n);
break;
case OBlogserver:
p = pserver(p, e, "logsrv", o, n);
break;
case OBcookieserver:
p = pserver(p, e, "cookiesrv", o, n);
break;
case OBlprserver:
p = pserver(p, e, "lprsrv", o, n);
break;
case OBimpressserver:
p = pserver(p, e, "impresssrv", o, n);
break;
case OBrlserver:
p = pserver(p, e, "rlsrv", o, n);
break;
case OBhostname:
p = pstring(p, e, "hostname", o, n);
break;
case OBbflen:
break;
case OBdumpfile:
p = pstring(p, e, "dumpfile", o, n);
break;
case OBdomainname:
p = pstring(p, e, "domname", o, n);
break;
case OBswapserver:
p = pserver(p, e, "swapsrv", o, n);
break;
case OBrootpath:
p = pstring(p, e, "rootpath", o, n);
break;
case OBextpath:
p = pstring(p, e, "extpath", o, n);
break;
case OBipforward:
p = phex(p, e, "ipforward", o, n);
break;
case OBnonlocal:
p = phex(p, e, "nonlocal", o, n);
break;
case OBpolicyfilter:
p = phex(p, e, "policyfilter", o, n);
break;
case OBmaxdatagram:
p = phex(p, e, "maxdatagram", o, n);
break;
case OBttl:
p = puint(p, e, "ttl", o, n);
break;
case OBpathtimeout:
p = puint(p, e, "pathtimeout", o, n);
break;
case OBpathplateau:
p = phex(p, e, "pathplateau", o, n);
break;
case OBmtu:
p = puint(p, e, "mtu", o, n);
break;
case OBsubnetslocal:
p = pserver(p, e, "subnet", o, n);
break;
case OBbaddr:
p = pserver(p, e, "baddr", o, n);
break;
case OBdiscovermask:
p = pserver(p, e, "discovermsak", o, n);
break;
case OBsupplymask:
p = pserver(p, e, "rousupplymaskter", o, n);
break;
case OBdiscoverrouter:
p = pserver(p, e, "discoverrouter", o, n);
break;
case OBrsserver:
p = pserver(p, e, "rsrouter", o, n);
break;
case OBstaticroutes:
p = phex(p, e, "staticroutes", o, n);
break;
case OBtrailerencap:
p = phex(p, e, "trailerencap", o, n);
break;
case OBarptimeout:
p = puint(p, e, "arptimeout", o, n);
break;
case OBetherencap:
p = phex(p, e, "etherencap", o, n);
break;
case OBtcpttl:
p = puint(p, e, "tcpttl", o, n);
break;
case OBtcpka:
p = puint(p, e, "tcpka", o, n);
break;
case OBtcpkag:
p = phex(p, e, "tcpkag", o, n);
break;
case OBnisdomain:
p = pstring(p, e, "nisdomain", o, n);
break;
case OBniserver:
p = pserver(p, e, "nisrv", o, n);
break;
case OBntpserver:
p = pserver(p, e, "ntpsrv", o, n);
break;
case OBvendorinfo:
p = phex(p, e, "vendorinfo", o, n);
break;
case OBnetbiosns:
p = pserver(p, e, "biosns", o, n);
break;
case OBnetbiosdds:
p = phex(p, e, "biosdds", o, n);
break;
case OBnetbiostype:
p = phex(p, e, "biostype", o, n);
break;
case OBnetbiosscope:
p = phex(p, e, "biosscope", o, n);
break;
case OBxfontserver:
p = pserver(p, e, "fontsrv", o, n);
break;
case OBxdispmanager:
p = pserver(p, e, "xdispmgr", o, n);
break;
case OBnisplusdomain:
p = pstring(p, e, "nisplusdomain", o, n);
break;
case OBnisplusserver:
p = pserver(p, e, "nisplussrv", o, n);
break;
case OBhomeagent:
p = pserver(p, e, "homeagent", o, n);
break;
case OBsmtpserver:
p = pserver(p, e, "smtpsrv", o, n);
break;
case OBpop3server:
p = pserver(p, e, "pop3srv", o, n);
break;
case OBnntpserver:
p = pserver(p, e, "ntpsrv", o, n);
break;
case OBwwwserver:
p = pserver(p, e, "wwwsrv", o, n);
break;
case OBfingerserver:
p = pserver(p, e, "fingersrv", o, n);
break;
case OBircserver:
p = pserver(p, e, "ircsrv", o, n);
break;
case OBstserver:
p = pserver(p, e, "stsrv", o, n);
break;
case OBstdaserver:
p = pserver(p, e, "stdasrv", o, n);
break;
case OBend:
goto out;
default:
snprint(msg, sizeof msg, " T%ud", code);
p = phex(p, e, msg, o, n);
break;
}
if(*ps != OBend)
p = seprint(p, e, " ");
}
out:
m->p = p;
m->ps = ps;
return 0;
}
static dl_error_t dl_internal_convert_write_struct( dl_ctx_t dl_ctx,
const uint8* data,
const SDLType* type,
SConvertContext& conv_ctx,
dl_binary_writer* writer )
{
dl_binary_writer_align( writer, type->alignment[conv_ctx.m_TargetPtrSize] );
pint Pos = dl_binary_writer_tell( writer );
dl_binary_writer_reserve( writer, type->size[conv_ctx.m_TargetPtrSize] );
for(uint32 iMember = 0; iMember < type->member_count; ++iMember)
{
const SDLMember& Member = type->members[iMember];
const uint8* pMemberData = data + Member.offset[conv_ctx.m_SourcePtrSize];
dl_binary_writer_align( writer, Member.alignment[conv_ctx.m_TargetPtrSize] );
dl_type_t AtomType = Member.AtomType();
dl_type_t StorageType = Member.StorageType();
switch(AtomType)
{
case DL_TYPE_ATOM_POD:
{
switch (StorageType)
{
case DL_TYPE_STORAGE_STRUCT:
{
const SDLType* pSubType = dl_internal_find_type(dl_ctx, Member.type_id);
if(pSubType == 0x0)
return DL_ERROR_TYPE_NOT_FOUND;
dl_internal_convert_write_struct( dl_ctx, pMemberData, pSubType, conv_ctx, writer );
}
break;
case DL_TYPE_STORAGE_STR:
{
pint Offset = DLInternalReadPtrData(pMemberData, conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize);
conv_ctx.m_lPatchOffset.Add( SConvertContext::PatchPos( dl_binary_writer_tell( writer ), Offset ) );
dl_binary_writer_write_ptr( writer, 0x0 );
}
break;
case DL_TYPE_STORAGE_PTR:
{
pint Offset = DLInternalReadPtrData(pMemberData, conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize);
if (Offset != DL_NULL_PTR_OFFSET[conv_ctx.m_SourcePtrSize])
conv_ctx.m_lPatchOffset.Add(SConvertContext::PatchPos( dl_binary_writer_tell( writer ), Offset ) );
dl_binary_writer_write_ptr( writer, pint(-1) );
}
break;
default:
DL_ASSERT(Member.IsSimplePod() || StorageType == DL_TYPE_STORAGE_ENUM);
dl_binary_writer_write_swap( writer, pMemberData, Member.size[conv_ctx.m_SourcePtrSize] );
break;
}
}
break;
case DL_TYPE_ATOM_INLINE_ARRAY:
{
switch(StorageType)
{
case DL_TYPE_STORAGE_STRUCT:
{
const SDLType* pSubType = dl_internal_find_type(dl_ctx, Member.type_id);
if(pSubType == 0x0)
return DL_ERROR_TYPE_NOT_FOUND;
pint MemberSize = Member.size[conv_ctx.m_SourcePtrSize];
pint SubtypeSize = pSubType->size[conv_ctx.m_SourcePtrSize];
for (pint ElemOffset = 0; ElemOffset < MemberSize; ElemOffset += SubtypeSize)
dl_internal_convert_write_struct( dl_ctx, pMemberData + ElemOffset, pSubType, conv_ctx, writer );
}
break;
case DL_TYPE_STORAGE_STR:
{
pint PtrSizeSource = dl_internal_ptr_size(conv_ctx.m_SourcePtrSize);
pint PtrSizeTarget = dl_internal_ptr_size(conv_ctx.m_TargetPtrSize);
uint32 Count = Member.size[conv_ctx.m_SourcePtrSize] / (uint32)PtrSizeSource;
pint Pos = dl_binary_writer_tell( writer );
for (pint iElem = 0; iElem < Count; ++iElem)
{
pint OldOffset = DLInternalReadPtrData(pMemberData + (iElem * PtrSizeSource), conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize);
conv_ctx.m_lPatchOffset.Add(SConvertContext::PatchPos(Pos + (iElem * PtrSizeTarget), OldOffset));
}
dl_binary_writer_write_zero( writer, Member.size[conv_ctx.m_TargetPtrSize] );
}
break;
default:
{
DL_ASSERT(Member.IsSimplePod() || StorageType == DL_TYPE_STORAGE_ENUM);
pint PodSize = DLPodSize(Member.type);
uint32 ArraySize = Member.size[conv_ctx.m_SourcePtrSize];
switch(PodSize)
{
case 1: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof( uint8), sizeof( uint8) ); break;
case 2: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof(uint16), sizeof(uint16) ); break;
case 4: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof(uint32), sizeof(uint32) ); break;
case 8: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof(uint64), sizeof(uint64) ); break;
default:
DL_ASSERT(false && "Not supported pod-size!");
}
}
break;
}
}
break;
case DL_TYPE_ATOM_ARRAY:
{
pint Offset = 0; uint32 Count = 0;
dl_internal_read_array_data( pMemberData, &Offset, &Count, conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize );
if(Offset != DL_NULL_PTR_OFFSET[conv_ctx.m_SourcePtrSize])
conv_ctx.m_lPatchOffset.Add(SConvertContext::PatchPos( dl_binary_writer_tell( writer ), Offset) );
else
Offset = DL_NULL_PTR_OFFSET[conv_ctx.m_TargetPtrSize];
dl_binary_writer_write_ptr( writer, Offset );
dl_binary_writer_write_4byte( writer, pMemberData + dl_internal_ptr_size( conv_ctx.m_SourcePtrSize ) );
if( conv_ctx.m_TargetPtrSize == DL_PTR_SIZE_64BIT )
dl_binary_writer_write_zero( writer, 4 );
}
break;
case DL_TYPE_ATOM_BITFIELD:
{
uint32 j = iMember;
do { j++; } while(j < type->member_count && type->members[j].AtomType() == DL_TYPE_ATOM_BITFIELD);
if(conv_ctx.m_SourceEndian != conv_ctx.m_TargetEndian)
{
uint32 nBFMembers = j - iMember;
switch(Member.size[conv_ctx.m_SourcePtrSize])
{
case 1:
{
uint8 val = dl_convert_bit_field_format_uint8( *(uint8*)pMemberData, &Member, nBFMembers, &conv_ctx );
dl_binary_writer_write_1byte( writer, &val );
} break;
case 2:
{
uint16 val = dl_convert_bit_field_format_uint16( *(uint16*)pMemberData, &Member, nBFMembers, &conv_ctx );
dl_binary_writer_write_2byte( writer, &val );
} break;
case 4:
{
uint32 val = dl_convert_bit_field_format_uint32( *(uint32*)pMemberData, &Member, nBFMembers, &conv_ctx );
dl_binary_writer_write_4byte( writer, &val );
} break;
case 8:
{
uint64 val = dl_convert_bit_field_format_uint64( *(uint64*)pMemberData, &Member, nBFMembers, &conv_ctx );
dl_binary_writer_write_8byte( writer, &val );
} break;
default:
DL_ASSERT(false && "Not supported pod-size or bitfield-size!");
}
}
else
dl_binary_writer_write( writer, pMemberData, Member.size[conv_ctx.m_SourcePtrSize] );
iMember = j - 1;
}
break;
default:
DL_ASSERT(false && "Invalid ATOM-type!");
}
}
// we need to write our entire size with zeroes. Our entire size might be less than the sum of teh members.
pint PosDiff = dl_binary_writer_tell( writer ) - Pos;
if(PosDiff < type->size[conv_ctx.m_TargetPtrSize])
dl_binary_writer_write_zero( writer, type->size[conv_ctx.m_TargetPtrSize] - PosDiff );
DL_ASSERT( dl_binary_writer_tell( writer ) - Pos == type->size[conv_ctx.m_TargetPtrSize] );
return DL_ERROR_OK;
}
time_t OETS_ASN1_TIME_get(ASN1_TIME *a, int *err)
{
int dummy;
const char *s;
int generalized;
struct tm t;
int i, year, isleap, offset;
time_t retval;
if (err == NULL) err = &dummy;
if (a->type == V_ASN1_GENERALIZEDTIME) {
generalized = 1;
} else if (a->type == V_ASN1_UTCTIME) {
generalized = 0;
} else {
*err = 1;
return 0;
}
s = (char *)a->data; // Data should be always null terminated
if (s == NULL || s[a->length] != '\0') {
*err = 1;
return 0;
}
*err = 0;
if (generalized) {
t.tm_year = pint(&s, 4, 0, 9999, err) - 1900;
} else {
t.tm_year = pint(&s, 2, 0, 99, err);
if (t.tm_year < 50) t.tm_year += 100;
}
t.tm_mon = pint(&s, 2, 1, 12, err) - 1;
t.tm_mday = pint(&s, 2, 1, 31, err);
// NOTE: It's not yet clear, if this implementation is 100% correct
// for GeneralizedTime... but at least misinterpretation is
// impossible --- we just throw an exception
t.tm_hour = pint(&s, 2, 0, 23, err);
t.tm_min = pint(&s, 2, 0, 59, err);
if (*s >= '0' && *s <= '9') {
t.tm_sec = pint(&s, 2, 0, 59, err);
} else {
t.tm_sec = 0;
}
if (*err) return 0; // Format violation
if (generalized) {
// skip fractional seconds if any
while (*s == '.' || *s == ',' || (*s >= '0' && *s <= '9')) ++s;
// special treatment for local time
if (*s == 0) {
t.tm_isdst = -1;
retval = mktime(&t); // Local time is easy :)
if (retval == (time_t)-1) {
*err = 2;
retval = 0;
}
return retval;
}
}
if (*s == 'Z') {
offset = 0;
++s;
} else if (*s == '-' || *s == '+') {
i = (*s++ == '-');
offset = pint(&s, 2, 0, 12, err);
offset *= 60;
offset += pint(&s, 2, 0, 59, err);
if (*err) return 0; // Format violation
if (i) offset = -offset;
} else {
*err = 1;
return 0;
}
if (*s) {
*err = 1;
return 0;
}
// And here comes the hard part --- there's no standard function to
// convert struct tm containing UTC time into time_t without
// messing global timezone settings (breaks multithreading and may
// cause other problems) and thus we have to do this "by hand"
//
// NOTE: Overflow check does not detect too big overflows, but is
// sufficient thanks to the fact that year numbers are limited to four
// digit non-negative values.
retval = t.tm_sec;
retval += (t.tm_min - offset) * 60;
retval += t.tm_hour * 3600;
retval += (t.tm_mday - 1) * 86400;
year = t.tm_year + 1900;
if (sizeof(time_t) == 4) {
// This is just to avoid too big overflows being undetected, finer
// overflow detection is done below.
if (year < 1900 || year > 2040) *err = 2;
}
// FIXME: Does POSIX really say, that all years divisible by 4 are
// leap years (for consistency)??? Fortunately, this problem does
// not exist for 32-bit time_t and we should'nt be worried about
// this until the year of 2100 :)
isleap = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
for (i = t.tm_mon - 1; i >= 0; --i) retval += days[isleap][i] * 86400;
retval += (year - 1970) * 31536000;
if (year < 1970) {
retval -= ((1970 - year + 2) / 4) * 86400;
if (sizeof(time_t) > 4) {
for (i = 1900; i >= year; i -= 100) {
if (i % 400 == 0) continue;
retval += 86400;
}
}
if (retval >= 0) *err = 2;
} else {
retval += ((year - 1970 + 1) / 4) * 86400;
if (sizeof(time_t) > 4) {
for (i = 2100; i < year; i += 100) {
// The following condition is the reason to
// start with 2100 instead of 2000
if (i % 400 == 0) continue;
retval -= 86400;
}
}
if (retval < 0) *err = 2;
}
if (*err) retval = 0;
return retval;
}
int pint (int n){int e; if(n<0) { prc('-'); n=NULL-n;}
if (n >= 10) {e=n/10; pint (e);} n=n%10; n=n+'0'; prc(n); }
static dl_error_t dl_internal_store_member( dl_ctx_t dl_ctx, const SDLMember* member, uint8* instance, CDLBinStoreContext* store_ctx )
{
dl_type_t atom_type = dl_type_t(member->type & DL_TYPE_ATOM_MASK);
dl_type_t storage_type = dl_type_t(member->type & DL_TYPE_STORAGE_MASK);
switch ( atom_type )
{
case DL_TYPE_ATOM_POD:
{
switch( storage_type )
{
case DL_TYPE_STORAGE_STRUCT:
{
const SDLType* sub_type = dl_internal_find_type( dl_ctx, member->type_id );
if( sub_type == 0x0 )
{
dl_log_error( dl_ctx, "Could not find subtype for member %s", member->name );
return DL_ERROR_TYPE_NOT_FOUND;
}
dl_internal_instance_store( dl_ctx, sub_type, instance, store_ctx );
}
break;
case DL_TYPE_STORAGE_STR:
dl_internal_store_string( instance, store_ctx );
break;
case DL_TYPE_STORAGE_PTR:
{
uint8* data = *(uint8**)instance;
pint offset = store_ctx->FindWrittenPtr( data );
if( data == 0x0 ) // Null-pointer, store pint(-1) to signal to patching!
{
DL_ASSERT(offset == pint(-1) && "This pointer should not have been found among the written ptrs!");
// keep the -1 in Offset and store it to ptr.
}
else if( offset == pint(-1) ) // has not been written yet!
{
pint pos = dl_binary_writer_tell( &store_ctx->writer );
dl_binary_writer_seek_end( &store_ctx->writer );
const SDLType* sub_type = dl_internal_find_type( dl_ctx, member->type_id );
pint size = dl_internal_align_up( sub_type->size[DL_PTR_SIZE_HOST], sub_type->alignment[DL_PTR_SIZE_HOST] );
dl_binary_writer_align( &store_ctx->writer, sub_type->alignment[DL_PTR_SIZE_HOST] );
offset = dl_binary_writer_tell( &store_ctx->writer );
// write data!
dl_binary_writer_reserve( &store_ctx->writer, size ); // reserve space for ptr so subdata is placed correctly
store_ctx->AddWrittenPtr(data, offset);
dl_internal_instance_store(dl_ctx, sub_type, data, store_ctx);
dl_binary_writer_seek_set( &store_ctx->writer, pos );
}
dl_binary_writer_write( &store_ctx->writer, &offset, sizeof(pint) );
}
break;
default: // default is a standard pod-type
DL_ASSERT( member->IsSimplePod() || storage_type == DL_TYPE_STORAGE_ENUM );
dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] );
break;
}
}
return DL_ERROR_OK;
case DL_TYPE_ATOM_INLINE_ARRAY:
{
switch( storage_type )
{
case DL_TYPE_STORAGE_STRUCT:
dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] ); // TODO: I Guess that this is a bug! Will it fix ptrs well?
break;
case DL_TYPE_STORAGE_STR:
{
uint32 count = member->size[DL_PTR_SIZE_HOST] / sizeof(char*);
for( uint32 elem = 0; elem < count; ++elem )
dl_internal_store_string( instance + (elem * sizeof(char*)), store_ctx );
}
break;
default: // default is a standard pod-type
DL_ASSERT( member->IsSimplePod() || storage_type == DL_TYPE_STORAGE_ENUM );
dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] );
break;
}
}
return DL_ERROR_OK;
case DL_TYPE_ATOM_ARRAY:
{
pint size = 0;
const SDLType* sub_type = 0x0;
uint8* data_ptr = instance;
uint32 count = *(uint32*)( data_ptr + sizeof(void*) );
pint offset = 0;
if( count == 0 )
offset = DL_NULL_PTR_OFFSET[ DL_PTR_SIZE_HOST ];
else
{
pint pos = dl_binary_writer_tell( &store_ctx->writer );
dl_binary_writer_seek_end( &store_ctx->writer );
switch(storage_type)
{
case DL_TYPE_STORAGE_STRUCT:
sub_type = dl_internal_find_type( dl_ctx, member->type_id );
size = dl_internal_align_up( sub_type->size[DL_PTR_SIZE_HOST], sub_type->alignment[DL_PTR_SIZE_HOST] );
dl_binary_writer_align( &store_ctx->writer, sub_type->alignment[DL_PTR_SIZE_HOST] );
break;
case DL_TYPE_STORAGE_STR:
size = sizeof(void*);
dl_binary_writer_align( &store_ctx->writer, size );
break;
default:
size = DLPodSize( member->type );
dl_binary_writer_align( &store_ctx->writer, size );
}
offset = dl_binary_writer_tell( &store_ctx->writer );
// write data!
dl_binary_writer_reserve( &store_ctx->writer, count * size ); // reserve space for array so subdata is placed correctly
uint8* data = *(uint8**)data_ptr;
switch(storage_type)
{
case DL_TYPE_STORAGE_STRUCT:
for ( unsigned int elem = 0; elem < count; ++elem )
dl_internal_instance_store( dl_ctx, sub_type, data + (elem * size), store_ctx );
break;
case DL_TYPE_STORAGE_STR:
for ( unsigned int elem = 0; elem < count; ++elem )
dl_internal_store_string( data + (elem * size), store_ctx );
break;
default:
for ( unsigned int elem = 0; elem < count; ++elem )
dl_binary_writer_write( &store_ctx->writer, data + (elem * size), size ); break;
}
dl_binary_writer_seek_set( &store_ctx->writer, pos );
}
// make room for ptr
dl_binary_writer_write( &store_ctx->writer, &offset, sizeof(pint) );
// write count
dl_binary_writer_write( &store_ctx->writer, &count, sizeof(uint32) );
}
return DL_ERROR_OK;
case DL_TYPE_ATOM_BITFIELD:
dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] );
break;
default:
DL_ASSERT(false && "Invalid ATOM-type!");
break;
}
return DL_ERROR_OK;
}
