// Test boost::tie() interoperabiliy.
int test_main( int, char* [] )
{
typedef X T ;
try
{
TRACE( std::endl << BOOST_CURRENT_FUNCTION );
T z(0);
T a(1);
T b(2);
optional<T> oa, ob ;
// T::T( T const& x ) is used
set_pending_dtor( ARG(T) ) ;
set_pending_copy( ARG(T) ) ;
boost::tie(oa,ob) = std::make_pair(a,b) ;
check_is_not_pending_dtor( ARG(T) ) ;
check_is_not_pending_copy( ARG(T) ) ;
check_initialized(oa);
check_initialized(ob);
check_value(oa,a,z);
check_value(ob,b,z);
}
catch ( ... )
{
BOOST_ERROR("Unexpected Exception caught!");
}
return 0;
}
int edcl_read(unsigned int address, void* obuf, size_t len)
{
check_initialized();
if(len > edcl_platform_get_maxpacket()) {
errno = EINVAL;
return -1;
}
address = htonl(address);
struct EdclPacket rq = {.control = edcl_control(seq++, 0, len), .address = address };
char buf[2000];
struct EdclPacket* rs = (struct EdclPacket*)buf;
ssize_t n = edcl_transaction(&rq, sizeof(rq), rs, sizeof(buf));
if(n < len + sizeof(*rs)) {
errno = EPROTO;
return -1;
}
if(rs->address != address || edcl_len(rs) != len) {
errno = EPROTO;
return -1;
}
memcpy(obuf, buf + sizeof(*rs), len);
return 0;
}
int edcl_write(unsigned int address, const void* ibuf, size_t len) {
char buf[2000] = {0};
check_initialized();
struct EdclPacket* rq = (struct EdclPacket*)buf;
struct EdclPacket rs;
if((len > edcl_platform_get_maxpacket()) || len > chip_config->maxpayload) {
errno = EINVAL;
fprintf(stderr, "payload too large: %zu \n",
len );
return -1;
}
rq->address = htonl(address);
rq->control = edcl_control(seq++, 1, len);
memcpy(buf + sizeof(*rq), ibuf, len);
return edcl_transaction(rq, sizeof(*rq) + len, &rs, sizeof(rs)) > 0 ? 0 : -1;
}
/*! \details This function gets the scheduling parameters from \a attr and
* stores it in \a param.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_getschedparam(const pthread_attr_t *attr /*! a pointer to the attributes structure */,
struct sched_param *param /*! the destination for the sched param value */){
if ( check_initialized(attr) < 0 ){
return -1;
}
memcpy(param, &(attr->schedparam), sizeof(struct sched_param));
return 0;
}
/*! \details This function gets the scheduling policy from \a attr and
* stores it in \a policy.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_getschedpolicy(const pthread_attr_t *attr /*! a pointer to the attributes structure */,
int *policy /*! the destination for the schedule policy value */){
if ( check_initialized(attr) < 0 ){
return -1;
}
*policy = PTHREAD_ATTR_GET_SCHED_POLICY(attr);
return 0;
}
/*! \details This function gets the detach state from \a attr and
* stores it in \a detachstate.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_getdetachstate(const pthread_attr_t * attr /*! a pointer to the attributes structure */,
int * detachstate /*! the destination for the detach state */){
if ( check_initialized(attr) < 0 ){
return -1;
}
*detachstate = PTHREAD_ATTR_GET_DETACH_STATE(attr);
return 0;
}
/*! \details This function gets the guard size from \a attr and
* stores it in \a guardsize.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_getguardsize(const pthread_attr_t * attr /*! a pointer to the attributes structure */,
size_t * guardsize /*! the destination for the new guard size */){
if ( check_initialized(attr) < 0 ){
return -1;
}
*guardsize = PTHREAD_ATTR_GET_GUARDSIZE(attr);
return 0;
}
/*! \details This functions gets the stack size from \a attr and
* stores it in \a stacksize.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_getstacksize(const pthread_attr_t *attr /*! a pointer to the attributes structure */,
size_t *stacksize /*! the destination for the new stack size */){
if ( check_initialized(attr) < 0 ){
return -1;
}
*stacksize = attr->stacksize;
return 0;
}
static int get_random( void )
{
check_initialized();
#if HAVE_RANDOM
return( (int) random() );
#else
return( (int) rand() );
#endif /* HAVE_RANDOM */
}
/*! \details This function gets the inherit sched value from \a attr and
* stores it in \a inheritsched.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_getinheritsched(const pthread_attr_t * attr /*! a pointer to the attributes structure */,
int * inheritsched /*! the destination for the inherit sched value */){
#ifndef _POSIX_THREAD_PRIORITY_SCHEDULING
errno = ENOSYS;
return -1;
#else
if ( check_initialized(attr) < 0 ){
return -1;
}
*inheritsched = PTHREAD_ATTR_GET_INHERIT_SCHED(attr);
return 0;
#endif
}
/*! \details This function sets the stack size in \a attr with \a stacksize.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
* - EINVAL: \a stacksize is too low of a value
* - ENOMEM: not enough memory
*/
int pthread_attr_setstacksize(pthread_attr_t *attr /*! a pointer to the attributes structure */,
size_t stacksize /*! the new stack size value */){
if ( check_initialized(attr) < 0 ){
return -1;
}
if( stacksize >= PTHREAD_STACK_MIN ){
attr->stacksize = stacksize;
return 0;
}
errno = EINVAL;
return -1;
}
/*! \details This function gets the contention scope from \a attr and
* stores it in \a contentionscope.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_getscope(const pthread_attr_t *attr /*! a pointer to the attributes structure */,
int *contentionscope /*! the destination for the contention scope value */){
#ifndef _POSIX_THREAD_PRIORITY_SCHEDULING
errno = ENOTSUP;
return -1;
#else
if ( check_initialized(attr) < 0 ){
return -1;
}
*contentionscope = PTHREAD_ATTR_GET_CONTENTION_SCOPE(attr);
return 0;
#endif
}
/*! \details This function sets the detach state in \a attr with \a detachstate.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
* - EINVAL: \a detachstate is not a valid
*/
int pthread_attr_setdetachstate(pthread_attr_t *attr /*! a pointer to the attributes structure */,
int detachstate /*! the new detach state (PTHREAD_CREATE_DETACHED or PTHREAD_CREATE_JOINABLE) */){
if ( check_initialized(attr) < 0 ){
return -1;
}
if ( (detachstate != PTHREAD_CREATE_DETACHED) &&
(detachstate != PTHREAD_CREATE_JOINABLE) ){
errno = EINVAL;
return -1;
}
PTHREAD_ATTR_SET_DETACH_STATE(attr, detachstate);
return 0;
}
/**
* Retrieve a GL function pointer given the function name.
*
* This function is similar to glXGetProcAddressARB(), except that:
*
* - It is platform-independent.
*
* - It may be called on any supported function, regardless of whether
* the function is defined in GL core or an extension, and
* regardless of whether desktop GL or GLES is in use.
*
* - Synonymous function names (e.g. glMapBuffer and glMapBufferARB)
* may be used interchangably; the correct function is automatically
* chosen based on the GL version and extension string.
*
* - If the requested function is not supported by the implementation,
* the unsupported_proc that was passed to piglit_dispatch_init() is
* called.
*/
piglit_dispatch_function_ptr
piglit_dispatch_resolve_function(const char *name)
{
size_t item_size = sizeof(function_names[0]);
size_t num_items = ARRAY_SIZE(function_names);
const char * const *item = (const char * const *)
bsearch(&name, function_names, num_items, item_size,
compare_function_names);
check_initialized();
if (!item) {
unsupported(name);
return NULL;
} else {
size_t item_index = item - function_names;
return function_resolvers[item_index]();
}
}
int oss_mixer_open(const char *pathname, int flags, ...)
{
int result;
check_initialized();
if (native_oss)
return open(pathname, flags);
result = x_oss_mixer_open(pathname, flags);
if (result >= 0) {
open_count++;
} else {
if (open_count == 0) {
dlclose(dl_handle);
dl_handle = NULL;
}
}
return result;
}
/*! \details This function sets the scheduling policy in \a attr with \a policy.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
* - EINVAL: \a policy does not refer to a valid policy.
*/
int pthread_attr_setschedpolicy(pthread_attr_t *attr /*! a pointer to the attributes structure */,
int policy /*! the new policy value (SCHED_FIFO, SCHED_RR, or SCHED_OTHER) */){
if ( check_initialized(attr) < 0 ){
return -1;
}
switch(policy){
case SCHED_FIFO:
case SCHED_RR:
case SCHED_OTHER:
PTHREAD_ATTR_SET_SCHED_POLICY(attr, policy);
return 0;
default:
errno = EINVAL;
return -1;
}
}
JNIEXPORT jobjectArray JNICALL
Java_com_zimbra_znative_ProxyInfo_getProxyInfo(JNIEnv *env, jclass cls, jstring jurl) {
check_initialized(env);
CFStringRef urlstr = getCFString(env, jurl);
CFURLRef url = CFURLCreateWithString(NULL, urlstr, NULL);
CFDictionaryRef systemProxy = CFNetworkCopySystemProxySettings();
CFArrayRef proxyArray = CFNetworkCopyProxiesForURL(url, systemProxy);
CFIndex size = CFArrayGetCount(proxyArray);
jobjectArray results = (*env)->NewObjectArray(env, (jsize) size, pi_cls, NULL);
int i;
for (i = 0; i < size; i++) {
CFDictionaryRef proxy = CFArrayGetValueAtIndex(proxyArray, i);
(*env)->SetObjectArrayElement(env, results, i, getProxyInfo(env, proxy));
}
CFRelease(proxyArray);
CFRelease(systemProxy);
CFRelease(url);
CFRelease(urlstr);
return results;
}
/*! \details This function sets the contention scope in \a attr with \a contentionscope.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
* - ENOTSUP: contentionscope is not PTHREAD_SCOPE_SYSTEM or PTHREAD_SCOPE_PROCESS
*/
int pthread_attr_setscope(pthread_attr_t *attr /*! a pointer to the attributes structure */,
int contentionscope /*! the new contention scope value */){
#ifndef _POSIX_THREAD_PRIORITY_SCHEDULING
errno = ENOSYS;
return -1;
#else
if ( check_initialized(attr) < 0 ){
return -1;
}
switch(contentionscope){
case PTHREAD_SCOPE_SYSTEM:
PTHREAD_ATTR_SET_CONTENTION_SCOPE(attr, contentionscope);
return 0;
case PTHREAD_SCOPE_PROCESS:
default:
errno = EINVAL;
return -1;
}
#endif
}
/*! \details This function sets the inherit sched in \a attr with \a inheritsched.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
* - EINVAL: \a inheritsched is not a valid value
*/
int pthread_attr_setinheritsched(pthread_attr_t *attr /*! a pointer to the attributes structure */,
int inheritsched /*! the new inherit sched value */){
#ifndef _POSIX_THREAD_PRIORITY_SCHEDULING
errno = ENOSYS;
return -1;
#else
if ( check_initialized(attr) < 0 ){
return -1;
}
if ( (inheritsched == PTHREAD_INHERIT_SCHED) ||
(inheritsched == PTHREAD_EXPLICIT_SCHED)){
PTHREAD_ATTR_SET_INHERIT_SCHED(attr, inheritsched);
return 0;
} else {
errno = EINVAL;
return -1;
}
#endif
}
/*! \details This function sets the scheduling parameters in \a attr with \a param.
* \return Zero on success or -1 with errno set to:
* - EINVAL: \a attr does not refer to an initialized thread attribute object
*/
int pthread_attr_setschedparam(pthread_attr_t *attr /*! a pointer to the attributes structure */,
const struct sched_param *param /*! the source for the sched param value */){
int policy;
if ( check_initialized(attr) < 0 ){
return -1;
}
policy = PTHREAD_ATTR_GET_SCHED_POLICY(attr);
if ( param->sched_priority < sched_get_priority_min(policy) ){
errno = EINVAL;
return -1;
}
if ( param->sched_priority > sched_get_priority_max(policy) ){
errno = EINVAL;
return -1;
}
memcpy(&(attr->schedparam), param, sizeof(struct sched_param));
return 0;
}
int main(int argc, char **argv) {
if (argc < 2) {
fprintf(stderr, "Usage: %s <command> [<args>]\n", argv[0]);
return 2;
}
// TODO: If students aren't going to write this themselves, replace by clean
// implementation using function pointers.
if (strcmp(argv[1], "init") == 0) {
if (check_initialized()) {
fprintf(stderr, "ERROR: Repository is already initialized\n");
return 1;
}
return beargit_init();
} else {
if (!check_initialized()) {
fprintf(stderr, "ERROR: Repository is not initialized\n");
return 1;
}
if (strcmp(argv[1], "add") == 0 || strcmp(argv[1], "rm") == 0) {
if (argc < 3 || !check_filename(argv[2])) {
fprintf(stderr, "ERROR: No or invalid filename given\n");
return 1;
}
if (strcmp(argv[1], "rm") == 0) {
return beargit_rm(argv[2]);
} else {
return beargit_add(argv[2]);
}
} else if (strcmp(argv[1], "commit") == 0) {
if (argc < 4 || strcmp(argv[2], "-m") != 0) {
fprintf(stderr, "ERROR: Need a commit message (-m <msg>)\n");
return 1;
}
if (strlen(argv[3]) > MSG_SIZE-1) {
fprintf(stderr, "ERROR: Message is too long!\n");
return 1;
}
return beargit_commit(argv[3]);
} else if (strcmp(argv[1], "status") == 0) {
return beargit_status();
} else if (strcmp(argv[1], "log") == 0) {
return beargit_log();
} else if (strcmp(argv[1], "branch") == 0) {
return beargit_branch();
} else if (strcmp(argv[1], "checkout") == 0) {
int branch_new = 0;
char* arg = NULL;
for (int i = 2; i < argc; i++) {
if (argv[i][0] == '-') {
if (strcmp(argv[i], "-b") == 0) {
branch_new = 1;
continue;
} else {
fprintf(stderr, "ERROR: Invalid argument: %s", argv[i]);
return 1;
}
}
if (arg) {
fprintf(stderr, "ERROR: Too many arguments for checkout!");
return 1;
}
arg = argv[i];
}
return beargit_checkout(arg, branch_new);
} else {
fprintf(stderr, "ERROR: Unknown command \"%s\"\n", argv[1]);
return 1;
}
}
}
// return cipher mode (such as CIPH_CBC_MODE, etc.)
int cipher_mode() const
{
check_initialized();
return CIPH_CBC_MODE;
}
