fastuidraw::c_array<uint8_t>
fastuidraw::GlyphRenderDataCoverage::
coverage_values(void)
{
  GlyphDataPrivate *d;
  d = reinterpret_cast<GlyphDataPrivate*>(m_d);
  return make_c_array(d->m_texels);
}
 static
 void
 fetch_resources(const T &src,
                 std::vector<reference_counted_ptr<const resource_base> > *dst)
 {
   dst->resize(src.number_resources());
   src.save_resources(make_c_array(*dst));
 }
 void
 initialize(const T &st,
            PackedValuePoolBase::Slot slot,
            PackedValuePoolBase *p)
 {
   this->initialize_common(slot, p);
   m_data.resize(st.data_size());
   st.pack_data(make_c_array(m_data));
   ResourceType::fetch_resources(st, &m_resources);
   BindImageType::fetch_bind_images(st, &m_bind_images);
   m_copy.copy_value(st);
 }
Example #4
0
fastuidraw::c_array<const fastuidraw::ColorStop>
fastuidraw::ColorStopSequence::
values(void) const
{
  ColorStopSequencePrivate *d;
  d = static_cast<ColorStopSequencePrivate*>(m_d);
  if (d->m_dirty)
    {
      d->m_dirty = false;
      std::stable_sort(d->m_values.begin(), d->m_values.end());
    }
  return make_c_array(d->m_values);
}
enum fastuidraw::return_code
fastuidraw::GlyphRenderDataCoverage::
upload_to_atlas(const GlyphAtlas::handle &atlas,
                GlyphLocation &atlas_location,
                GlyphLocation &secondary_atlas_location,
                int &geometry_offset,
                int &geometry_length) const
{
  GlyphDataPrivate *d;
  d = reinterpret_cast<GlyphDataPrivate*>(m_d);
  atlas_location = atlas->allocate(d->m_resolution, make_c_array(d->m_texels));
  secondary_atlas_location = GlyphLocation();
  geometry_offset = -1;
  geometry_length = 0;

  return atlas_location.valid() ?
    routine_success :
    routine_fail;
}
Example #6
0
    void compiler::compiler_main(const string& cpp_path, const string& out_path, const vector<string>& params) {
        /*
        Remove .so file to avoid overwriting, which causes problems when
        unloading servlets. Reason: before unloading a servlet the destroy methon needs to
        be called. If the servlet gets overwritten, then call'ing it's method causes a SEGV

        Don't check the return value. The file may not exist - this is not an error.
        In case of other errors - they will be reported later (presumably by the compiler, when trying to overwrite)
        */
        unlink(out_path.c_str());
        
        static const char* static_argv[] = {
            "/usr/bin/g++",
            "-shared",
            "-fPIC",
            "-o"
        };
        static const size_t static_argv_size = 4;
        
        vector<string> args;
        args.reserve(
            sizeof(static_argv) +
            2 +
            2*includes_.size() + 
            params.size()
        );
        
        for(unsigned i=0; i<static_argv_size;++i)
            args.push_back(static_argv[i]);
        args.push_back(out_path);
        args.push_back(cpp_path);
        for(unsigned i=0; i<includes_.size(); ++i) {
            args.push_back("-I");
            args.push_back(includes_[i]);
        }
        for(unsigned i=0; i<default_flags_.size(); ++i)
            args.push_back(default_flags_[i]);
        for(unsigned i=0; i<params.size(); ++i)
            args.push_back(params[i]);
        
        ofstream err("/tmp/cxxsp.log");
        err << "\nThe full command is:\n\t"; 
        for(unsigned i=1; i<args.size(); ++i)
            err << args[i] << ' ';
        err << endl;
        err.close();

        /*
        Note: No need for memory management.
        In a momemt this process will exit and all the memory will be freed
        */
        char** argv = make_c_array(args);
        if(execv(static_argv[0], argv) == -1) {
            perror("Failed to execute the compiler");
            cerr << "\nThe full command is:\n\t"; 
            for(unsigned i=1; i<args.size(); ++i)
                cerr << args[i] << ' ';
            cerr << endl;
            exit(111);
        }
        exit(222);
    }
Example #7
0
File: ol_ldap.c Project: hww3/pexts
/*
 **| method: object search ( mapping params );
 **|   This is the preferred way of calling this method.
 **
 **| alt: object search ( string filter );
 **| alt: object search ( string filter, array attrs );
 **| alt: object search ( string filter, array attrs, int attrsonly );
 **| alt: object search ( string filter, array attrs, int attrsonly, int timeout );
 **
 **| general: search the LDAP directory for the specified entry
 **|   (entries). The first form is the preferred one as it
 **|   encompasses all the current and future parameters as expected
 **|   by the underlying API. The following fields are read from the
 **|   mapping:@nl
 **|
 **|   @list
 **|    * base - the base DN to use in this search. Overrides the
 **|      default base DN (as set with set_base_dn)
 **|    * scope - the search scope for this search. Overrides the
 **|      default scope (as set with set_scope)
 **|    * filter - the search filter. The BNF for the filter is as
 **|      follows:
 **|      @pre
 **|        <filter> ::= `(' <filtercomp> `)'
 **|        <filtercomp> ::= <and> | <or> | <not> | <simple>
 **|        <and> ::= `&' <filterlist>
 **|        <or> ::= `|' <filterlist>
 **|        <not> ::= `!' <filter>
 **|        <filterlist> ::= <filter> | <filter> <filterlist>
 **|        <simple> ::= <attributetype> <filtertype> <attributevalue>
 **|        <filtertype> ::= `=' | `~=' | `<=' | `>='
 **|      @pre_end
 **|    * attrs - search attributes. An array of attribute types to
 **|      return in the result. If absent, all types will be returned.
 **|    * attrsonly - if != then the result will contain attribute
 **|      types only - no values shall be returned.
 **|    * timeout - the timeout, in seconds, after which the call
 **|      should return if the search isn't finished.
 **|   @list_end
 */
static void
f_ldap_search(INT32 args)
{
    char                *filter;
    int                  scope;
    struct pike_string  *base;
    char               **attrs;
    int                  attrsonly;
    struct timeval      *timeout;
    LDAPMessage         *res;
    int                  ret;
    struct object       *obj;

    if (!THIS->bound)
        Pike_error("OpenLDAP.Client: attempting operation on an unbound connection\n");
    
    if (!args)
        Pike_error("OpenLDAP.Client->search() requires at least one argument\n");

    if (args == 1) {
        switch(ARG(1).type) {
            case T_MAPPING:
            {
                /* the new style case */
                struct svalue  *val;
                struct mapping *m = ARG(1).u.mapping;

                /*
                 * m->base
                 */
                val = low_mapping_string_lookup(m,
                                                base_str);
                if (!val || val->type != T_STRING)
                    base = THIS->basedn;
                else
                    base = val->u.string;

                /*
                 * m->scope
                 */
                val = low_mapping_string_lookup(m,
                                                scope_str);
                if (!val || val->type != T_INT)
                    scope = THIS->scope;
                else
                    scope = val->u.integer;

                /*
                 * m->filter
                 */
                val = low_mapping_string_lookup(m,
                                                filter_str);
                if (!val || val->type != T_STRING)
                    filter = OL_DEF_FILTER;
                else
                    filter = val->u.string->str;

                /*
                 * m->attrs
                 */
                val = low_mapping_string_lookup(m,
                                                attrs_str);
                if (!val || val->type != T_ARRAY)
                    attrs = NULL;
                else
                    attrs = make_c_array(val);

                /*
                 * m->attrsonly
                 */
                val = low_mapping_string_lookup(m,
                                                attrsonly_str);
                if (!val || val->type != T_INT)
                    attrsonly = 0;
                else
                    attrsonly = val->u.integer != 0;

                /*
                 * m->timeout
                 */
                val = low_mapping_string_lookup(m,
                                                timeout_str);
                if (!val || val->type != T_INT)
                    timeout = NULL;
                else
                    timeout = make_timeout(val->u.integer); /*TEMPORARY*/
                
                break;
            }

            case T_STRING:
                /* the old style case */                
                base = THIS->basedn;
                scope = THIS->scope;
                filter = ARG(1).u.string->str;
                attrs = NULL;
                attrsonly = 0;
                timeout = NULL;
                break;

            default:
                Pike_error("OpenLDAP.Client->search() with single argument requires either a mapping or a string\n");
                break;
        }
    } else switch(args) {
        case 4: /* timeout */
            if (ARG(4).type != T_INT)
                Pike_error("OpenLDAP.Client->search(): argument 4 must be an integer\n");
            else
                timeout = make_timeout(ARG(4).u.integer);
            /* fall through */

        case 3: /* attrsonly */
            if (ARG(3).type != T_INT)
                Pike_error("OpenLDAP.Client->search(): argument 3 must be an integer\n");
            else
                attrsonly = ARG(3).u.integer != 0;
            /* fall through */

        case 2: /* attrs */
            if (ARG(2).type != T_ARRAY)
                Pike_error("OpenLDAP.Client->search(): argument 2 must be an array\n");
            else
                attrs = make_c_array(&ARG(2));

            base = THIS->basedn;
            scope = THIS->scope;
            filter = ARG(1).u.string->str;
            attrsonly = 0;
            timeout = NULL;
            break;

        default:
            Pike_error("OpenLDAP.Client->search(): incorrect number of arguments\n");
            break;
    }

    ret = timeout ?
        ldap_search_st(THIS->conn,
                       base->str,
                       scope,
                       filter,
                       attrs,
                       attrsonly,
                       timeout,
                       &res) :
        ldap_search_s(THIS->conn,
                      base->str,
                      scope,
                      filter,
                      attrs,
                      attrsonly,
                      &res);    
    
    if (ret)
        Pike_error("OpenLDAP.Client->search(): %s\n",
                   ldap_err2string(ret));

    pop_n_elems(args);
    
    THIS->data = res;
    obj = clone_object(result_program, 0);
    push_object(obj);
    
    if (attrs)
        free(attrs);
}