static void add_authors( HWND list ) { static const WCHAR eol[] = {'\r','\n',0}; static const WCHAR authors[] = {'A','U','T','H','O','R','S',0}; WCHAR *strW, *start, *end; HRSRC rsrc = FindResourceW( shell32_hInstance, authors, (LPCWSTR)RT_RCDATA ); char *strA = LockResource( LoadResource( shell32_hInstance, rsrc )); DWORD sizeW, sizeA = SizeofResource( shell32_hInstance, rsrc ); if (!strA) return; sizeW = MultiByteToWideChar( CP_UTF8, 0, strA, sizeA, NULL, 0 ) + 1; if (!(strW = HeapAlloc( GetProcessHeap(), 0, sizeW * sizeof(WCHAR) ))) return; MultiByteToWideChar( CP_UTF8, 0, strA, sizeA, strW, sizeW ); strW[sizeW - 1] = 0; start = strpbrkW( strW, eol ); /* skip the header line */ while (start) { while (*start && strchrW( eol, *start )) start++; if (!*start) break; end = strpbrkW( start, eol ); if (end) *end++ = 0; SendMessageW( list, LB_ADDSTRING, -1, (LPARAM)start ); start = end; } HeapFree( GetProcessHeap(), 0, strW ); }
static void processRegLinesW(FILE *in) { WCHAR* buf = NULL; /* line read from input stream */ ULONG lineSize = REG_VAL_BUF_SIZE; size_t CharsInBuf = -1; WCHAR* s; /* The pointer into buf for where the current fgets should read */ WCHAR* line; /* The start of the current line */ buf = HeapAlloc(GetProcessHeap(), 0, lineSize * sizeof(WCHAR)); CHECK_ENOUGH_MEMORY(buf); s = buf; line = buf; while(!feof(in)) { size_t size_remaining; int size_to_get; WCHAR *s_eol = NULL; /* various local uses */ /* Do we need to expand the buffer ? */ assert (s >= buf && s <= buf + lineSize); size_remaining = lineSize - (s-buf); if (size_remaining < 2) /* room for 1 character and the \0 */ { WCHAR *new_buffer; size_t new_size = lineSize + (REG_VAL_BUF_SIZE / sizeof(WCHAR)); if (new_size > lineSize) /* no arithmetic overflow */ new_buffer = HeapReAlloc (GetProcessHeap(), 0, buf, new_size * sizeof(WCHAR)); else new_buffer = NULL; CHECK_ENOUGH_MEMORY(new_buffer); buf = new_buffer; line = buf; s = buf + lineSize - size_remaining; lineSize = new_size; size_remaining = lineSize - (s-buf); } /* Get as much as possible into the buffer, terminated either by * eof, error or getting the maximum amount. Abort on error. */ size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining); CharsInBuf = fread(s, sizeof(WCHAR), size_to_get - 1, in); s[CharsInBuf] = 0; if (CharsInBuf == 0) { if (ferror(in)) { perror ("While reading input"); exit (IO_ERROR); } else { assert (feof(in)); *s = '\0'; /* It is not clear to me from the definition that the * contents of the buffer are well defined on detecting * an eof without managing to read anything. */ } } /* If we didn't read the eol nor the eof go around for the rest */ while(1) { const WCHAR line_endings[] = {'\r','\n',0}; s_eol = strpbrkW(line, line_endings); if(!s_eol) { /* Move the stub of the line to the start of the buffer so * we get the maximum space to read into, and so we don't * have to recalculate 'line' if the buffer expands */ MoveMemory(buf, line, (strlenW(line)+1) * sizeof(WCHAR)); line = buf; s = strchrW(line, '\0'); break; } /* If it is a comment line then discard it and go around again */ if (*line == '#' || *line == ';') { if (*s_eol == '\r' && *(s_eol+1) == '\n') line = s_eol + 2; else line = s_eol + 1; continue; } /* If there is a concatenating \\ then go around again */ if (*(s_eol-1) == '\\') { WCHAR* NextLine = s_eol + 1; if(*s_eol == '\r' && *(s_eol+1) == '\n') NextLine++; while(*(NextLine+1) == ' ' || *(NextLine+1) == '\t') NextLine++; MoveMemory(s_eol - 1, NextLine, (CharsInBuf - (NextLine - s) + 1)*sizeof(WCHAR)); CharsInBuf -= NextLine - s_eol + 1; s_eol = 0; continue; } /* Remove any line feed. Leave s_eol on the last \0 */ if (*s_eol == '\r' && *(s_eol + 1) == '\n') *s_eol++ = '\0'; *s_eol = '\0'; processRegEntry(line, TRUE); line = s_eol + 1; s_eol = 0; continue; /* That is the full virtual line */ } } processRegEntry(NULL, TRUE); HeapFree(GetProcessHeap(), 0, buf); }
int wmain(int argc, WCHAR *argv[]) { WCHAR name[MAX_PATH]; WCHAR *namepart; WCHAR curdir[MAX_PATH]; WCHAR originalname[MAX_PATH]; DWORD attrib_set = 0; DWORD attrib_clear = 0; BOOL attrib_recurse = FALSE; BOOL attrib_includedirs = FALSE; static const WCHAR help_option[] = {'/','?','\0'}; static const WCHAR wildcardsW[] = {'*','?','\0'}; int i = 1; BOOL found = FALSE; if ((argc >= 2) && !strcmpW(argv[1], help_option)) { ATTRIB_wprintf(ATTRIB_LoadMessage(STRING_HELP)); return 0; } /* By default all files from current directory are taken into account */ strcpyW(name, starW); while (i < argc) { WCHAR *param = argv[i++]; WINE_TRACE("Processing arg: '%s'\n", wine_dbgstr_w(param)); if ((param[0] == '+') || (param[0] == '-')) { DWORD attrib = 0; switch (param[1]) { case 'H': case 'h': attrib |= FILE_ATTRIBUTE_HIDDEN; break; case 'S': case 's': attrib |= FILE_ATTRIBUTE_SYSTEM; break; case 'R': case 'r': attrib |= FILE_ATTRIBUTE_READONLY; break; case 'A': case 'a': attrib |= FILE_ATTRIBUTE_ARCHIVE; break; default: ATTRIB_wprintf(ATTRIB_LoadMessage(STRING_NYI)); return 0; } switch (param[0]) { case '+': attrib_set = attrib; break; case '-': attrib_clear = attrib; break; } } else if (param[0] == '/') { if (((param[1] == 'D') || (param[1] == 'd')) && !param[2]) { attrib_includedirs = TRUE; } else if (((param[1] == 'S') || (param[1] == 's')) && !param[2]) { attrib_recurse = TRUE; } else { WINE_FIXME("Unknown option %s\n", debugstr_w(param)); } } else if (param[0]) { strcpyW(originalname, param); } } /* Name may be a relative or explicit path, so calculate curdir based on current locations, stripping off the filename */ WINE_TRACE("Supplied name: '%s'\n", wine_dbgstr_w(originalname)); GetFullPathNameW(originalname, sizeof(curdir)/sizeof(WCHAR), curdir, &namepart); WINE_TRACE("Result: '%s'\n", wine_dbgstr_w(curdir)); if (namepart) { strcpyW(name, namepart); *namepart = 0; } else { name[0] = 0; } /* If a directory is explicitly supplied on the command line, and no wildcards are in the name, then allow it to be changed/displayed */ if (strpbrkW(originalname, wildcardsW) == NULL) attrib_includedirs = TRUE; /* Do all the processing based on the filename arg */ found = ATTRIB_processdirectory(curdir, name, attrib_recurse, attrib_includedirs, attrib_set, attrib_clear); if (!found) { ATTRIB_wprintf(ATTRIB_LoadMessage(STRING_FILENOTFOUND), originalname); } return 0; }
/********************************************************************* * wcspbrk (NTDLL.@) */ LPWSTR __cdecl NTDLL_wcspbrk( LPCWSTR str, LPCWSTR accept ) { return strpbrkW( str, accept ); }
/*********************************************************************** * parse_locale_name * * Parse a locale name into a struct locale_name, handling both Windows and Unix formats. * Unix format is: lang[_country][.charset][@modifier] * Windows format is: lang[-script][-country][_modifier] */ static void parse_locale_name( const WCHAR *str, struct locale_name *name ) { static const WCHAR sepW[] = {'-','_','.','@',0}; static const WCHAR winsepW[] = {'-','_',0}; static const WCHAR posixW[] = {'P','O','S','I','X',0}; static const WCHAR cW[] = {'C',0}; static const WCHAR latinW[] = {'l','a','t','i','n',0}; static const WCHAR latnW[] = {'-','L','a','t','n',0}; WCHAR *p; int ind; // TRACE("%s\n", debugstr_w(str)); name->country = name->charset = name->script = name->modifier = NULL; name->lcid = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT ); name->matches = 0; name->codepage = 0; name->win_name[0] = 0; lstrcpynW( name->lang, str, sizeof(name->lang)/sizeof(WCHAR) ); if (!(p = strpbrkW( name->lang, sepW ))) { if (!strcmpW( name->lang, posixW ) || !strcmpW( name->lang, cW )) { name->matches = 4; /* perfect match for default English lcid */ return; } strcpyW( name->win_name, name->lang ); } else if (*p == '-') /* Windows format */ { strcpyW( name->win_name, name->lang ); *p++ = 0; name->country = p; if (!(p = strpbrkW( p, winsepW ))) goto done; if (*p == '-') { *p++ = 0; name->script = name->country; name->country = p; if (!(p = strpbrkW( p, winsepW ))) goto done; } *p++ = 0; name->modifier = p; } else /* Unix format */ { if (*p == '_') { *p++ = 0; name->country = p; p = strpbrkW( p, sepW + 2 ); } if (p && *p == '.') { *p++ = 0; name->charset = p; p = strchrW( p, '@' ); } if (p) { *p++ = 0; name->modifier = p; } if (name->charset) name->codepage = find_charset( name->charset ); /* rebuild a Windows name if possible */ if (name->charset) goto done; /* can't specify charset in Windows format */ if (name->modifier && strcmpW( name->modifier, latinW )) goto done; /* only Latn script supported for now */ strcpyW( name->win_name, name->lang ); if (name->modifier) strcatW( name->win_name, latnW ); if (name->country) { p = name->win_name + strlenW(name->win_name); *p++ = '-'; strcpyW( p, name->country ); } } done: ; /* DEBUG printf("EnumResourceLanguagesW(...):\n"); printf(" name->win_name=%ls\n", name->win_name); printf(" name->lang=%ls\n", name->lang); printf(" name->country=%ls\n", name->country); printf(" name->codepage=%d\n", name->codepage); */ // EnumResourceLanguagesW( kernel32_handle, (LPCWSTR)RT_STRING, (LPCWSTR)LOCALE_ILANGUAGE, // find_locale_id_callback, (LPARAM)name ); ind = 0; while (g_langInfo[ind].LOCALE_SNAME) { BOOL ret = find_locale_id_callback(&g_langInfo[ind],name); if (ret == FALSE) break; ind++; } }