自学教程：C++ strdupW函数代码示例

static UINT msi_media_get_disk_info( MSIPACKAGE *package, struct media_info *mi ){    MSIRECORD *row;    LPWSTR ptr;    static const WCHAR query[] =        {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',         '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',         '`','D','i','s','k','I','d','`',' ','=',' ','%','i',0};    row = MSI_QueryGetRecord(package->db, query, mi->disk_id);    if (!row)    {        TRACE("Unable to query row/n");        return ERROR_FUNCTION_FAILED;    }    mi->disk_prompt = strdupW(MSI_RecordGetString(row, 3));    mi->cabinet = strdupW(MSI_RecordGetString(row, 4));    mi->volume_label = strdupW(MSI_RecordGetString(row, 5));    if (!mi->first_volume)        mi->first_volume = strdupW(mi->volume_label);    ptr = strrchrW(mi->source, '//') + 1;    lstrcpyW(ptr, mi->cabinet);    msiobj_release(&row->hdr);    return ERROR_SUCCESS;}

static LPWSTR get_ini_field(LPWSTR buf, int field){    LPWSTR beg, end;    int i = 1;    if (field == 0)        return strdupW(buf);    beg = buf;    while ((end = strchrW(beg, ',')) && i < field)    {        beg = end + 1;        while (*beg && *beg == ' ')            beg++;        i++;    }    end = strchrW(beg, ',');    if (!end)        end = beg + lstrlenW(beg);    *end = '/0';    return strdupW(beg);}

static HRESULT parse_culture(IAssemblyNameImpl *name, LPCWSTR culture){    static const WCHAR empty[] = {0};    if (lstrlenW(culture) == 2)        name->culture = strdupW(culture);    else        name->culture = strdupW(empty);    return S_OK;}

static WCHAR *strstriW(const WCHAR *str, const WCHAR *sub){    LPWSTR strlower, sublower, r;    strlower = CharLowerW(strdupW(str));    sublower = CharLowerW(strdupW(sub));    r = strstrW(strlower, sublower);    if (r)        r = (LPWSTR)str + (r - strlower);    heap_free(strlower);    heap_free(sublower);    return r;}

/****************************************************************************** * backend_load [internal] * * load and init a backend * * PARAMS *  name   [I] Printprovider to use for the backend. NULL for the local print provider * * RETURNS *  Success: PTR to the backend *  Failure: NULL * */static backend_t * backend_load(LPWSTR dllname, LPWSTR name, LPWSTR regroot){    BOOL (WINAPI *pInitializePrintProvidor)(LPPRINTPROVIDOR, DWORD, LPWSTR);    DWORD id;    DWORD res;    TRACE("(%s, %s, %s)/n", debugstr_w(dllname), debugstr_w(name), debugstr_w(regroot));    EnterCriticalSection(&backend_cs);    id = used_backends;    backend[id] = heap_alloc_zero(sizeof(backend_t));    if (!backend[id]) {        LeaveCriticalSection(&backend_cs);        return NULL;    }    backend[id]->dllname = strdupW(dllname);    backend[id]->name = strdupW(name);    backend[id]->regroot = strdupW(regroot);    backend[id]->dll = LoadLibraryW(dllname);    if (backend[id]->dll) {        pInitializePrintProvidor = (void *) GetProcAddress(backend[id]->dll, "InitializePrintProvidor");        if (pInitializePrintProvidor) {            /* native localspl does not clear unused entries */            res = pInitializePrintProvidor((PRINTPROVIDOR *) backend[id], sizeof(PRINTPROVIDOR), regroot);            if (res) {                used_backends++;                backend[id]->index = used_backends;                LeaveCriticalSection(&backend_cs);                TRACE("--> backend #%d: %p (%s)/n", id, backend[id], debugstr_w(dllname));                return backend[id];            }        }        FreeLibrary(backend[id]->dll);    }    heap_free(backend[id]->dllname);    heap_free(backend[id]->name);    heap_free(backend[id]->regroot);    heap_free(backend[id]);    backend[id] = NULL;    LeaveCriticalSection(&backend_cs);    WARN("failed to init %s: %u/n", debugstr_w(dllname), GetLastError());    return NULL;}

static LANGID *parse_languages( const WCHAR *languages, DWORD *num_ids ){    UINT i, count = 1;    WCHAR *str = strdupW( languages ), *p, *q;    LANGID *ret;    if (!str) return NULL;    for (p = q = str; (q = strchrW( q, ',' )); q++) count++;    if (!(ret = msi_alloc( count * sizeof(LANGID) )))    {        msi_free( str );        return NULL;    }    i = 0;    while (*p)    {        q = strchrW( p, ',' );        if (q) *q = 0;        ret[i] = atoiW( p );        if (!q) break;        p = q + 1;        i++;    }    msi_free( str );    *num_ids = count;    return ret;}

static UINT ACTION_AppSearchIni(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig){    static const WCHAR query[] =  {        's','e','l','e','c','t',' ','*',' ',        'f','r','o','m',' ',        'I','n','i','L','o','c','a','t','o','r',' ',        'w','h','e','r','e',' ',        'S','i','g','n','a','t','u','r','e','_',' ','=',' ','/'','%','s','/'',0};    MSIRECORD *row;    LPWSTR fileName, section, key;    int field, type;    WCHAR buf[MAX_PATH];    TRACE("%s/n", debugstr_w(sig->Name));    *appValue = NULL;    row = MSI_QueryGetRecord( package->db, query, sig->Name );    if (!row)    {        TRACE("failed to query IniLocator for %s/n", debugstr_w(sig->Name));        return ERROR_SUCCESS;    }    fileName = msi_dup_record_field(row, 2);    section = msi_dup_record_field(row, 3);    key = msi_dup_record_field(row, 4);    field = MSI_RecordGetInteger(row, 5);    type = MSI_RecordGetInteger(row, 6);    if (field == MSI_NULL_INTEGER)        field = 0;    if (type == MSI_NULL_INTEGER)        type = 0;    GetPrivateProfileStringW(section, key, NULL, buf, MAX_PATH, fileName);    if (buf[0])    {        switch (type & 0x0f)        {        case msidbLocatorTypeDirectory:            FIXME("unimplemented for Directory (%s)/n", debugstr_w(buf));            break;        case msidbLocatorTypeFileName:            FIXME("unimplemented for File (%s)/n", debugstr_w(buf));            break;        case msidbLocatorTypeRawValue:            *appValue = strdupW(buf);            break;        }    }    msi_free(fileName);    msi_free(section);    msi_free(key);    msiobj_release(&row->hdr);    return ERROR_SUCCESS;}

UINT MSI_RecordSetStringW( MSIRECORD *rec, UINT iField, LPCWSTR szValue ){    LPWSTR str;    TRACE("%p %d %s/n", rec, iField, debugstr_w(szValue));    if( iField > rec->count )        return ERROR_INVALID_FIELD;    MSI_FreeField( &rec->fields[iField] );    if( szValue && szValue[0] )    {        str = strdupW( szValue );        rec->fields[iField].type = MSIFIELD_WSTR;        rec->fields[iField].u.szwVal = str;    }    else    {        rec->fields[iField].type = MSIFIELD_NULL;        rec->fields[iField].u.szwVal = NULL;    }    return 0;}

/** * get_config_key: Retrieves a configuration value from the registry * * char *subkey : the name of the config section * char *name : the name of the config value * char *default : if the key isn't found, return this value instead * * Returns a buffer holding the value if successful, NULL if * not. Caller is responsible for releasing the result. * */static WCHAR *get_config_key (HKEY root, const WCHAR *subkey, const WCHAR *name, const WCHAR *def){    LPWSTR buffer = NULL;    DWORD len;    HKEY hSubKey = NULL;    DWORD res;    WINE_TRACE("subkey=%s, name=%s, def=%s/n", wine_dbgstr_w(subkey),               wine_dbgstr_w(name), wine_dbgstr_w(def));    res = RegOpenKeyExW(root, subkey, 0, MAXIMUM_ALLOWED, &hSubKey);    if (res != ERROR_SUCCESS)    {        if (res == ERROR_FILE_NOT_FOUND)        {            WINE_TRACE("Section key not present - using default/n");            return def ? strdupW(def) : NULL;        }        else        {            WINE_ERR("RegOpenKey failed on wine config key (res=%d)/n", res);        }        goto end;    }    res = RegQueryValueExW(hSubKey, name, NULL, NULL, NULL, &len);    if (res == ERROR_FILE_NOT_FOUND)    {        WINE_TRACE("Value not present - using default/n");        buffer = def ? strdupW(def) : NULL;	goto end;    } else if (res != ERROR_SUCCESS)    {        WINE_ERR("Couldn't query value's length (res=%d)/n", res);        goto end;    }    buffer = HeapAlloc(GetProcessHeap(), 0, len + sizeof(WCHAR));    RegQueryValueExW(hSubKey, name, NULL, NULL, (LPBYTE) buffer, &len);    WINE_TRACE("buffer=%s/n", wine_dbgstr_w(buffer));end:    RegCloseKey(hSubKey);    return buffer;}

HRESULT IAssemblyName_SetPath(IAssemblyName *iface, LPCWSTR path){    IAssemblyNameImpl *name = unsafe_impl_from_IAssemblyName(iface);    name->path = strdupW(path);    if (!name->path)        return E_OUTOFMEMORY;    return S_OK;}

/************************************************************************ *           PSDRV_StartDoc */INT PSDRV_StartDoc( PHYSDEV dev, const DOCINFOW *doc ){    PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );    DOC_INFO_1W di;    PRINTER_DEFAULTSW prn_def;    TRACE("(%p, %p) => %s, %s, %s/n", physDev, doc, debugstr_w(doc->lpszDocName),        debugstr_w(doc->lpszOutput), debugstr_w(doc->lpszDatatype));    if(physDev->job.id) {        FIXME("hJob != 0. Now what?/n");	return 0;    }    prn_def.pDatatype = NULL;    prn_def.pDevMode = &physDev->pi->Devmode->dmPublic;    prn_def.DesiredAccess = PRINTER_ACCESS_USE;    if (!OpenPrinterW( physDev->pi->friendly_name, &physDev->job.hprinter, &prn_def ))    {        WARN("OpenPrinter(%s, ...) failed: %d/n",            debugstr_w(physDev->pi->friendly_name), GetLastError());        return 0;    }    di.pDocName = (LPWSTR) doc->lpszDocName;    di.pDatatype = NULL;    if(doc->lpszOutput)        di.pOutputFile = (LPWSTR) doc->lpszOutput;    else if(physDev->job.output)        di.pOutputFile = physDev->job.output;    else        di.pOutputFile = NULL;    TRACE("using output: %s/n", debugstr_w(di.pOutputFile));    /* redirection located in HKCU/Software/Wine/Printing/Spooler       is done during winspool.drv,ScheduleJob */    physDev->job.id = StartDocPrinterW(physDev->job.hprinter, 1, (LPBYTE) &di);    if(!physDev->job.id) {        WARN("StartDocPrinter() failed: %d/n", GetLastError());        ClosePrinter(physDev->job.hprinter);	return 0;    }    physDev->job.banding = FALSE;    physDev->job.OutOfPage = TRUE;    physDev->job.PageNo = 0;    physDev->job.quiet = FALSE;    physDev->job.in_passthrough = FALSE;    physDev->job.had_passthrough_rect = FALSE;    physDev->job.doc_name = strdupW( doc->lpszDocName );    return physDev->job.id;}

HRESULT assembly_create(ASSEMBLY **out, LPCWSTR file){    ASSEMBLY *assembly;    HRESULT hr;    *out = NULL;    assembly = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ASSEMBLY));    if (!assembly)        return E_OUTOFMEMORY;    assembly->path = strdupW(file);    if (!assembly->path)    {        hr = E_OUTOFMEMORY;        goto failed;    }    assembly->hfile = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ,                                  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);    if (assembly->hfile == INVALID_HANDLE_VALUE)    {        hr = HRESULT_FROM_WIN32(GetLastError());        goto failed;    }    assembly->hmap = CreateFileMappingW(assembly->hfile, NULL, PAGE_READONLY,                                        0, 0, NULL);    if (!assembly->hmap)    {        hr = HRESULT_FROM_WIN32(GetLastError());        goto failed;    }    assembly->data = MapViewOfFile(assembly->hmap, FILE_MAP_READ, 0, 0, 0);    if (!assembly->data)    {        hr = HRESULT_FROM_WIN32(GetLastError());        goto failed;    }    hr = parse_pe_header(assembly);    if (FAILED(hr)) goto failed;    hr = parse_clr_metadata(assembly);    if (FAILED(hr)) goto failed;    *out = assembly;    return S_OK;failed:    assembly_release(assembly);    return hr;}

static void add_device(IMMDevice *device, LPCWSTR devid, vector_DevMap *list){    DevMap entry;    AL_STRING_INIT(entry.name);    entry.devid = strdupW(devid);    get_device_name(device, &entry.name);    TRACE("Got device /"%s/", /"%ls/"/n", al_string_get_cstr(entry.name), entry.devid);    VECTOR_PUSH_BACK(*list, entry);}

HRESULT BackgroundCopyFileConstructor(BackgroundCopyJobImpl *owner,                                      LPCWSTR remoteName, LPCWSTR localName,                                      BackgroundCopyFileImpl **file){    BackgroundCopyFileImpl *This;    TRACE("(%s, %s, %p)/n", debugstr_w(remoteName), debugstr_w(localName), file);    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);    if (!This)        return E_OUTOFMEMORY;    This->info.RemoteName = strdupW(remoteName);    if (!This->info.RemoteName)    {        HeapFree(GetProcessHeap(), 0, This);        return E_OUTOFMEMORY;    }    This->info.LocalName = strdupW(localName);    if (!This->info.LocalName)    {        HeapFree(GetProcessHeap(), 0, This->info.RemoteName);        HeapFree(GetProcessHeap(), 0, This);        return E_OUTOFMEMORY;    }    This->IBackgroundCopyFile2_iface.lpVtbl = &BackgroundCopyFile2Vtbl;    This->ref = 1;    This->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;    This->fileProgress.BytesTransferred = 0;    This->fileProgress.Completed = FALSE;    This->owner = owner;    This->read_size = 0;    This->tempFileName[0] = 0;    IBackgroundCopyJob3_AddRef(&owner->IBackgroundCopyJob3_iface);    *file = This;    return S_OK;}

static UINT check_directory( MSIPACKAGE *package, const WCHAR *dir, WCHAR **appValue ){    DWORD attr = msi_get_file_attributes( package, dir );    if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))    {        TRACE("directory exists, returning %s/n", debugstr_w(dir));        *appValue = strdupW(dir);    }    return ERROR_SUCCESS;}

static UINT ACTION_CheckDirectory(MSIPACKAGE *package, LPCWSTR dir, LPWSTR *appValue){    DWORD attr = GetFileAttributesW(dir);    if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))    {        TRACE("directory exists, returning %s/n", debugstr_w(dir));        *appValue = strdupW(dir);    }    return ERROR_SUCCESS;}

static void add_device(IMMDevice *device, DevMap *devmap){    LPWSTR devid;    HRESULT hr;    hr = IMMDevice_GetId(device, &devid);    if(SUCCEEDED(hr))    {        devmap->devid = strdupW(devid);        devmap->name = get_device_name(device);        TRACE("Got device /"%s/", /"%ls/"/n", devmap->name, devmap->devid);        CoTaskMemFree(devid);    }}

BOOL validate_service_config(struct service_entry *entry){    if (entry->config.dwServiceType & SERVICE_WIN32 && (entry->config.lpBinaryPathName == NULL || !entry->config.lpBinaryPathName[0]))    {        WINE_ERR("Service %s is Win32 but has no image path set/n", wine_dbgstr_w(entry->name));        return FALSE;    }    switch (entry->config.dwServiceType)    {    case SERVICE_KERNEL_DRIVER:    case SERVICE_FILE_SYSTEM_DRIVER:    case SERVICE_WIN32_OWN_PROCESS:    case SERVICE_WIN32_SHARE_PROCESS:        /* No problem */        break;    case SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS:    case SERVICE_WIN32_SHARE_PROCESS | SERVICE_INTERACTIVE_PROCESS:        /* These can be only run as LocalSystem */        if (entry->config.lpServiceStartName && strcmpiW(entry->config.lpServiceStartName, SZ_LOCAL_SYSTEM) != 0)        {            WINE_ERR("Service %s is interactive but has a start name/n", wine_dbgstr_w(entry->name));            return FALSE;        }        break;    default:        WINE_ERR("Service %s has an unknown service type (0x%x)/n", wine_dbgstr_w(entry->name), entry->config.dwServiceType);        return FALSE;    }    /* StartType can only be a single value (if several values are mixed the result is probably not what was intended) */    if (entry->config.dwStartType > SERVICE_DISABLED)    {        WINE_ERR("Service %s has an unknown start type/n", wine_dbgstr_w(entry->name));        return FALSE;    }    /* SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services */    if (((entry->config.dwStartType == SERVICE_BOOT_START) || (entry->config.dwStartType == SERVICE_SYSTEM_START)) &&        ((entry->config.dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (entry->config.dwServiceType & SERVICE_WIN32_SHARE_PROCESS)))    {        WINE_ERR("Service %s - SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services/n", wine_dbgstr_w(entry->name));        return FALSE;    }    if (entry->config.lpServiceStartName == NULL)        entry->config.lpServiceStartName = strdupW(SZ_LOCAL_SYSTEM);    return TRUE;}

UINT MSI_RecordCopyField( MSIRECORD *in_rec, UINT in_n,                          MSIRECORD *out_rec, UINT out_n ){    UINT r = ERROR_SUCCESS;    msiobj_lock( &in_rec->hdr );    if ( in_n > in_rec->count || out_n > out_rec->count )        r = ERROR_FUNCTION_FAILED;    else if ( in_rec != out_rec || in_n != out_n )    {        LPWSTR str;        MSIFIELD *in, *out;        in = &in_rec->fields[in_n];        out = &out_rec->fields[out_n];        switch ( in->type )        {        case MSIFIELD_NULL:            break;        case MSIFIELD_INT:            out->u.iVal = in->u.iVal;            break;        case MSIFIELD_INTPTR:            out->u.pVal = in->u.pVal;            break;        case MSIFIELD_WSTR:            str = strdupW( in->u.szwVal );            if ( !str )                r = ERROR_OUTOFMEMORY;            else                out->u.szwVal = str;            break;        case MSIFIELD_STREAM:            IStream_AddRef( in->u.stream );            out->u.stream = in->u.stream;            break;        default:            ERR("invalid field type %d/n", in->type);        }        if (r == ERROR_SUCCESS)            out->type = in->type;    }    msiobj_unlock( &in_rec->hdr );    return r;}

/*********************************************************************** *      ldap_encode_sort_controlW     ([email
C++ strdup_w函数代码示例
C++ strdata函数代码示例