Convert-Binary-C
view release on metacpan or search on metacpan
tests/include/pdclib/functions/_tzcode/_PDCLIB_gmtcheck.ctests/include/pdclib/functions/_tzcode/_PDCLIB_gmtsub.ctests/include/pdclib/functions/_tzcode/_PDCLIB_increment_overflow.ctests/include/pdclib/functions/_tzcode/_PDCLIB_init_ttinfo.ctests/include/pdclib/functions/_tzcode/_PDCLIB_localsub.ctests/include/pdclib/functions/_tzcode/_PDCLIB_localtime_tzset.ctests/include/pdclib/functions/_tzcode/_PDCLIB_mktime_tzname.ctests/include/pdclib/functions/_tzcode/_PDCLIB_timesub.ctests/include/pdclib/functions/_tzcode/_PDCLIB_tzload.ctests/include/pdclib/functions/_tzcode/_PDCLIB_tzparse.ctests/include/pdclib/functions/_tzcode/_PDCLIB_tzset_unlocked.ctests/include/pdclib/functions/_tzcode/_PDCLIB_update_tzname_etc.ctests/include/pdclib/functions/_tzcode/Readme.txttests/include/pdclib/functions/ctype/isalnum.ctests/include/pdclib/functions/ctype/isalpha.ctests/include/pdclib/functions/ctype/isblank.ctests/include/pdclib/functions/ctype/iscntrl.ctests/include/pdclib/functions/ctype/isdigit.ctests/include/pdclib/functions/ctype/isgraph.ctests/include/pdclib/functions/ctype/islower.ctests/include/pdclib/functions/ctype/isprint.c
get_and_check_backslash_N_name_wrapper|5.029009||Viuget_ANYOF_cp_list_for_ssc|5.019005||Viuget_ANYOFM_contents|5.027009||ViuGETATARGET|5.003007||Viuget_aux_mg|5.011000||Viuget_av|5.006000|5.003007|pgetc|5.003007||Viuget_c_backtrace|5.021001||Viget_c_backtrace_dump|5.021001||Vget_context|5.006000|5.006000|nugetc_unlocked|5.003007||Viuget_cv|5.006000|5.003007|pget_cvn_flags|5.009005|5.003007|pget_cvs|5.011000|5.003007|pgetcwd_sv|5.007002|5.007002|get_db_sub|||iuget_debug_opts|5.008001||Viuget_deprecated_property_msg|5.031011||cVniugetegid|5.005000||Viugetenv|5.005000||Viugetenv_len|5.006000||Viu
PERL_MAGIC_vec|5.007002|5.003007|pPERL_MAGIC_vstring|5.008001|5.003007|pPERL_MAGIC_VTABLE_MASK|5.015000||ViuPERL_MALLOC_CTL_H|5.027001||ViuPerl_malloc_good_size|5.010001||ViuPERL_MALLOC_WRAP|5.009002|5.009002|VnPerlMem_calloc|5.006000||ViuPerlMem_free|5.005000||ViuPerlMem_free_lock|5.006000||ViuPerlMem_get_lock|5.006000||ViuPerlMem_is_locked|5.006000||ViuPerlMem_malloc|5.005000||ViuPERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||ViuPerlMemParse_calloc|5.006000||ViuPerlMemParse_free|5.006000||ViuPerlMemParse_free_lock|5.006000||ViuPerlMemParse_get_lock|5.006000||ViuPerlMemParse_is_locked|5.006000||ViuPerlMemParse_malloc|5.006000||ViuPerlMemParse_realloc|5.006000||ViuPerlMem_realloc|5.005000||ViuPerlMemShared_calloc|5.006000||ViuPerlMemShared_free|5.006000||ViuPerlMemShared_free_lock|5.006000||ViuPerlMemShared_get_lock|5.006000||ViuPerlMemShared_is_locked|5.006000||ViuPerlMemShared_malloc|5.006000||ViuPerlMemShared_realloc|5.006000||ViuPERL_MG_UFUNC|5.007001||ViuPerl_modf|5.006000|5.006000|nPERL_MULTICONCAT_HEADER_SIZE|5.027006||ViuPERL_MULTICONCAT_IX_LENGTHS|5.027006||ViuPERL_MULTICONCAT_IX_NARGS|5.027006||ViuPERL_MULTICONCAT_IX_PLAIN_LEN|5.027006||ViuPERL_MULTICONCAT_IX_PLAIN_PV|5.027006||ViuPERL_MULTICONCAT_IX_UTF8_LEN|5.027006||Viu
PUSHSTACKi|5.005000||ViuPUSHSTACK_INIT_HWM|5.027002||ViuPUSHTARG|5.003007||ViuPUSHu|5.004000|5.003007|pPUTBACK|5.003007|5.003007|putc|5.003007||Viuput_charclass_bitmap_innards|5.021004||Viuput_charclass_bitmap_innards_common|5.023008||Viuput_charclass_bitmap_innards_invlist|5.023008||Viuput_code_point|5.021004||Viuputc_unlocked|5.003007||Viuputenv|5.005000||Viuput_range|5.019009||Viuputw|5.003007||Viupv_display|5.006000|5.003007|ppv_escape|5.009004|5.003007|ppv_pretty|5.009004|5.003007|ppv_uni_display|5.007003|5.007003|pWARN_ALL|5.006000||ViupWARN_NONE|5.006000||ViupWARN_STD|5.006000||Viu
tests/include/pdclib/CMakeLists.txt view on Meta::CPAN
functions/_tzcode/_PDCLIB_gmtcheck.cfunctions/_tzcode/_PDCLIB_gmtsub.cfunctions/_tzcode/_PDCLIB_increment_overflow.cfunctions/_tzcode/_PDCLIB_init_ttinfo.cfunctions/_tzcode/_PDCLIB_localsub.cfunctions/_tzcode/_PDCLIB_localtime_tzset.cfunctions/_tzcode/_PDCLIB_mktime_tzname.cfunctions/_tzcode/_PDCLIB_timesub.cfunctions/_tzcode/_PDCLIB_tzload.cfunctions/_tzcode/_PDCLIB_tzparse.cfunctions/_tzcode/_PDCLIB_tzset_unlocked.cfunctions/_tzcode/_PDCLIB_update_tzname_etc.cfunctions/_PDCLIB/assert.cfunctions/_PDCLIB/errno.cfunctions/_PDCLIB/_PDCLIB_atomax.cfunctions/_PDCLIB/_PDCLIB_bigint.cfunctions/_PDCLIB/_PDCLIB_bigint2.cfunctions/_PDCLIB/_PDCLIB_bigint10.cfunctions/_PDCLIB/_PDCLIB_bigint32.cfunctions/_PDCLIB/_PDCLIB_bigint64.c
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
using already-existing space will be serviced via mmap. (If enoughnormal freed space alreadyexistsit is used instead.) Using mmapsegregates relatively large chunks of memory so that they can beindividually obtained and released from the hostsystem. A requestserviced through mmap is never reused by any other request (at leastnot directly; thesystemmay just so happen to remap successiverequests to the same locations). Segregating space in this wayhasthe benefits that: Mmapped space can always be individually releasedback to thesystem, which helps keep thesystemlevel memory demandsof a long-lived program low. Also, mapped memory doesn't become`locked' between other chunks, as can happenwithnormally allocatedchunks, which means that even trimming via malloc_trim would notrelease them. However, ithasthe disadvantage that the spacecannot be reclaimed, consolidated, and then used to service laterrequests, as happenswithnormal chunks. The advantages of mmapnearly always outweigh disadvantagesfor"large"chunks, but thevalue of"large"may vary across systems. Thedefaultis anempirically derived value that works well in most systems. You candisable mmap by setting to MAX_SIZE_T.MAX_RELEASE_CHECK_RATEdefault: 4095unlessnot HAVE_MMAP
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
/*malloc_trim(size_t pad);If possible, gives memory back to thesystem(via negative argumentsto sbrk)ifthere is unused memory at the `high' end of the mallocpool or in unused MMAP segments. You can call thisafterfreeinglarge blocks of memory to potentially reduce thesystem-level memoryrequirements of a program. However, it cannot guarantee to reducememory. Under some allocation patterns, some large free blocks ofmemory will be locked between two used chunks, so they cannot begivenback to thesystem.The `pad' argument to malloc_trim represents the amount of freetrailing space to leave untrimmed. If this argument is zero, onlythe minimum amount of memory to maintain internal data structureswill be left. Non-zero arguments can be supplied to maintain enoughtrailing space to service future expected allocations without havingto re-obtain memory from thesystem.Malloc_trim returns 1ifit actually released any memory,else0.
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
/*mspace is an opaque type representing an independentregion of space that supports mspace_malloc, etc.*/typedef void* mspace;/*create_mspace creates and returns a new independent spacewiththegiveninitial capacity, or,if0, thedefaultgranularity size. Itreturns nullifthere isnosystemmemory available to create thespace. If argument locked is non-zero, the space uses a separatelockto control access. The capacity of the space will growdynamically as needed to service mspace_malloc requests. You cancontrol the sizes of incremental increases of this space bycompilingwitha different DEFAULT_GRANULARITY or dynamicallysettingwithmallopt(M_GRANULARITY, value).*/DLMALLOC_EXPORT mspace create_mspace(size_t capacity,intlocked);/*destroy_mspace destroys thegivenspace, and attempts toreturnallof its memory back to thesystem, returning the total number ofbytes freed. After destruction, the results of access to all memoryused by the space become undefined.*/DLMALLOC_EXPORT size_t destroy_mspace(mspace msp);/*create_mspace_with_base uses the memory supplied as the initial baseof a new mspace. Part (less than 128*sizeof(size_t) bytes) of thisspace is usedforbookkeeping, so the capacity must be at least thislarge. (Otherwise 0 is returned.) When this initial space isexhausted, additional memory will be obtained from thesystem.Destroying this space will deallocate all additionally allocatedspace (ifpossible) but not the initial base.*/DLMALLOC_EXPORT mspace create_mspace_with_base(void* base, size_t capacity,intlocked);/*mspace_track_large_chunks controls whether requestsforlarge chunksare allocated in their own untracked mmapped regions, separate fromothers in this mspace. Bydefaultlarge chunks are not tracked,which reduces fragmentation. However, such chunks are notnecessarily released to thesystemupon destroy_mspace. Enablingtracking by setting to true may increase fragmentation, but avoidsleakagewhenrelying on destroy_mspace to release all memoryallocated using this space. The function returns the previous
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
#endif /* solaris or LACKS_SCHED_H */#if (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0) || !USE_SPIN_LOCKS#include <pthread.h>#endif /* USE_RECURSIVE_LOCKS ... */#elif defined(_MSC_VER)#ifndef _M_AMD64/* These are alreadydefinedon AMD64 builds */#ifdef __cplusplusextern"C"{#endif /* __cplusplus */LONG __cdecl _InterlockedCompareExchange(LONG volatile*Dest, LONG Exchange, LONG Comp);LONG __cdecl _InterlockedExchange(LONG volatile*Target, LONG Value);#ifdef __cplusplus}#endif /* __cplusplus */#endif /* _M_AMD64 */#pragma intrinsic (_InterlockedCompareExchange)#pragma intrinsic (_InterlockedExchange)#define interlockedcompareexchange _InterlockedCompareExchange#define interlockedexchange _InterlockedExchange#elif defined(WIN32) && defined(__GNUC__)#define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)#define interlockedexchange __sync_lock_test_and_set#endif /* Win32 */#else /* USE_LOCKS */#endif /* USE_LOCKS */#ifndef LOCK_AT_FORK#define LOCK_AT_FORK 0#endif/* Declarationsforbit scanning on win32 */#if defined(_MSC_VER) && _MSC_VER>=1300
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
__asm__ __volatile__ ("lock; xchgl %0, %1":"=r"(ret):"m"(*(sl)),"0"(prev):"memory");}#define CAS_LOCK(sl) x86_cas_lock(sl)#define CLEAR_LOCK(sl) x86_clear_lock(sl)#else /* Win32 MSC */#define CAS_LOCK(sl) interlockedexchange(sl, (LONG)1)#define CLEAR_LOCK(sl) interlockedexchange (sl, (LONG)0)#endif /* ... gcc spins locks ... *//* How to yieldfora spinlock*/#define SPINS_PER_YIELD 63#if defined(_MSC_VER)#define SLEEP_EX_DURATION 50 /* delay for yield/sleep */#define SPIN_LOCK_YIELD SleepEx(SLEEP_EX_DURATION, FALSE)#elif defined (__SVR4) && defined (__sun) /* solaris */#define SPIN_LOCK_YIELD thr_yield();
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
static volatile LONG malloc_global_mutex_status;/* Use spin loop to initialize globallock*/static void init_malloc_global_mutex() {for(;;) {longstat= malloc_global_mutex_status;if(stat> 0)return;/* transition to < 0whileinitializing, then to > 0) */if(stat== 0 &&interlockedcompareexchange(&malloc_global_mutex_status, (LONG)-1, (LONG)0) == 0) {InitializeCriticalSection(&malloc_global_mutex);interlockedexchange(&malloc_global_mutex_status, (LONG)1);return;}SleepEx(0, FALSE);}}#else /* pthreads-based locks */#define MLOCK_T pthread_mutex_t#define ACQUIRE_LOCK(lk) pthread_mutex_lock(lk)#define RELEASE_LOCK(lk) pthread_mutex_unlock(lk)
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
m->extp = 0;m->exts = 0;disable_contiguous(m);init_bins(m);mn = next_chunk(mem2chunk(m));init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE);check_top_chunk(m, m->top);returnm;}mspace create_mspace(size_t capacity,intlocked) {mstate m = 0;size_t msize;ensure_initialization();msize = pad_request(sizeof(struct malloc_state));if(capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {size_t rs = ((capacity == 0)? mparams.granularity :(capacity + TOP_FOOT_SIZE + msize));size_t tsize = granularity_align(rs);char* tbase = (char*)(CALL_MMAP(tsize));if(tbase != CMFAIL) {m = init_user_mstate(tbase, tsize);m->seg.sflags = USE_MMAP_BIT;set_lock(m, locked);}}return(mspace)m;}mspace create_mspace_with_base(void* base, size_t capacity,intlocked) {mstate m = 0;size_t msize;ensure_initialization();msize = pad_request(sizeof(struct malloc_state));if(capacity > msize + TOP_FOOT_SIZE &&capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {m = init_user_mstate((char*)base, capacity);m->seg.sflags = EXTERN_BIT;set_lock(m, locked);}return(mspace)m;}intmspace_track_large_chunks(mspace msp,intenable) {intret = 0;mstate ms = (mstate)msp;if(!PREACTION(ms)) {if(!use_mmap(ms)) {ret = 1;
tests/include/pdclib/functions/_dlmalloc/malloc.c view on Meta::CPAN
regions in those cases where theydohappen to be contiguous.* MORECORE need not handle negative arguments -- it may insteadjustreturnMFAILwhengivennegative arguments.Negative arguments are always multiples of pagesize. MORECOREmust not misinterpret negative args as large positive unsignedargs. You can suppress all such calls from even occurring by definingMORECORE_CANNOT_TRIM,As an example alternative MORECORE, here is a custom allocatorkindly contributedforpre-OSX macOS. It uses virtually but notnecessarily physically contiguous non-paged memory (locked in,this section, adding some#includes, and setting up the appropriatedefines above:#define MORECORE osMoreCoreThere is also ashutdownroutine that should somehow be calledforcleanup upon programexit.#define MAX_POOL_ENTRIES 100
tests/include/pdclib/functions/_tzcode/_PDCLIB_localtime_tzset.c view on Meta::CPAN
#endif#include <string.h>struct tm * _PDCLIB_localtime_tzset( time_t const * timep, struct tm * tmp, bool setname ){_PDCLIB_LOCK( _PDCLIB_time_mtx );if( setname || ! lcl_is_set ){_PDCLIB_tzset_unlocked();}tmp = _PDCLIB_localsub(&_PDCLIB_lclmem, timep, setname, tmp );_PDCLIB_UNLOCK( _PDCLIB_time_mtx );returntmp;}#endif#ifdef TEST
tests/include/pdclib/functions/_tzcode/_PDCLIB_tzset_unlocked.c view on Meta::CPAN
/* _PDCLIB_tzset_unlocked( void )This file is part of the Public Domain C Library (PDCLib).Permission is granted touse, modify, and / or redistribute at will.*/#ifndef REGTEST#include "pdclib/_PDCLIB_tzcode.h"#include <stdlib.h>
tests/include/pdclib/functions/_tzcode/_PDCLIB_tzset_unlocked.c view on Meta::CPAN
if( 0 < lcl ){strcpy( lcl_TZname, name );}}settzname();lcl_is_set = lcl;}void _PDCLIB_tzset_unlocked( void ){tzsetlcl( getenv("TZ") );}#endif#ifdef TEST#include "_PDCLIB_test.h"
tests/include/pdclib/functions/stdio/freopen.c view on Meta::CPAN
#ifndef __STDC_NO_THREADS__if( mtx_init(&stream->mtx, mtx_plain | mtx_recursive ) != thrd_success ){/* Could not initialize stream mutex */_PDCLIB_UNLOCK( _PDCLIB_filelist_mtx );returnNULL;}#endif/* Locking the mutex, so we come out of theif-elsewitha lockedmutex either way.*/_PDCLIB_LOCK( stream->mtx );}/* Stream is closed, or never wasopen(even though its mutexexistsand is locked) at this point.Now we checkifwe have the whereabouts toopenit.*/if( filemode == 0 ){/* Mode invalid */_PDCLIB_UNLOCK( stream->mtx );#ifndef __STDC_NO_THREADS__mtx_destroy(&stream->mtx );#endif
tests/include/pdclib/functions/time/mktime.c view on Meta::CPAN
#ifndef __STDC_NO_THREADS__#include <threads.h>extern mtx_t _PDCLIB_time_mtx;#endiftime_t mktime( struct tm * timeptr ){time_t t;_PDCLIB_LOCK( _PDCLIB_time_mtx );_PDCLIB_tzset_unlocked();t = _PDCLIB_mktime_tzname(&_PDCLIB_lclmem, timeptr, true );_PDCLIB_UNLOCK( _PDCLIB_time_mtx );returnt;}#endif#ifdef TEST#include "_PDCLIB_test.h"
tests/include/pdclib/include/pdclib/_PDCLIB_tzcode.h view on Meta::CPAN
void _PDCLIB_gmtcheck(void);struct tm * _PDCLIB_gmtsub( struct state const * sp, time_t const * timep, int_fast32_t offset, struct tm * tmp );bool _PDCLIB_increment_overflow(int* ip,intj );void _PDCLIB_init_ttinfo( struct ttinfo * s, int_fast32_t utoff, bool isdst,intdesigidx );struct tm * _PDCLIB_localsub( struct state const * sp, time_t const * timep, int_fast32_t setname, struct tm * const tmp );struct tm * _PDCLIB_localtime_tzset( time_t const * timep, struct tm * tmp, bool setname );time_t _PDCLIB_mktime_tzname( struct state * sp, struct tm * tmp, bool setname );struct tm * _PDCLIB_timesub( const time_t * timep, int_fast32_t offset, const struct state * sp, struct tm * tmp );int_PDCLIB_tzload( char const * name, struct state * sp, bool doextend );bool _PDCLIB_tzparse(char const *, struct state *, bool);void _PDCLIB_tzset_unlocked( void );void _PDCLIB_update_tzname_etc( struct state const * sp, struct ttinfo const * ttisp );#ifdef __cplusplus}#endif#endif
tests/include/pdclib/platform/example/include/signal.h view on Meta::CPAN
arrangements, it is not possible to turn them into a useful tool.This example implementation chose to "not generate any of these signals,except as a result of explicit calls to the raise function", which isallowed by the standard but of course does nothingforthe usefulness of<signal.h>.A useful signal handling would:1) make signal() asystemcall that registers the signal handlerwiththe OS2) make raise() asystemcall triggering an OS signal to the running process3) make provisions that further signals of the same type are blockeduntilthe signal handler returns (optionalforSIGILL)*//* These are thevaluesused by Linux. *//* Abnormal termination / abort() */#define SIGABRT 6/* Arithmetic exception / division by zero / overflow */#define SIGFPE 8/* Illegal instruction */
tests/include/pdclib/platform/example/include/threads.h view on Meta::CPAN
mtx_plain -- non-recursive mutexmtx_timed -- non-recursive mutex supporting timeoutmtx_plain | mtx_recursive -- recursive mutexmtx_timed | mtx_recursive -- recursive mutex supporting timeout*/_PDCLIB_PUBLICintmtx_init( mtx_t * mtx,inttype );/* Try tolockthegivenmutex (blocking).Returns thrd_successifsuccessful, thrd_errorifthe request could notbe honored.If thegivenmutex is non-recursive, it must not be already locked bythe calling thread.*/_PDCLIB_PUBLICintmtx_lock( mtx_t * mtx );/* TODO: Documentation.Returns thrd_successifsuccessful, thrd_timedoutifthe specifiedtimeis reached without acquiring the resource, or thrd_errorifthe requestcould not be honored.*/_PDCLIB_PUBLICintmtx_timedlock( mtx_t * _PDCLIB_restrict mtx, const struct timespec * _PDCLIB_restrict ts );/* Try tolockthegivenmutex (non-blocking).Returns thrd_successifsuccessful, thrd_busyifthe resource is alreadylocked, or thrd_errorifthe request could not be honored.*/_PDCLIB_PUBLICintmtx_trylock( mtx_t * mtx );/* Unlock thegivenmutex.Returns thrd_successifsuccessful, thrd_errorifthe request could notbe honored.Thegivenmutex must be locked by the calling thread.*/_PDCLIB_PUBLICintmtx_unlock( mtx_t * mtx );/* Thread functions *//* Create a new thread.Returns thrd_successifsuccessful, thrd_nomemifout of memory, andthrd_errorifthe request could not be honored.Create a new thread executing func( arg ), and sets thr to identifythe created thread. (Identifiers may be reused afer a thread exited
( run in 0.503 second using v1.01-cache-2.11-cpan-3cd7ad12f66 )