trurl/wmaker
1
0
Fork 0
forked from vitrine/wmaker
Code Pull Requests Activity

Reimplement the PropList data structure in Rust.

Browse Source 
While this large change has some unit tests, it has not been integration tested
thoroughly. Removing the global case insensitivity flag may be an issue in
particular.

A few of PropList API functions have been modified (mostly to get rid of
varargs). The definition of one such function has been left in C for cleanup
later.
This commit is contained in:
trurl
2025-10-23 14:46:56 -04:00
parent 5b593fb19a
commit f3961ba66f
32 changed files with 3417 additions and 1966 deletions
Download Patch File Download Diff File Expand all files Collapse all files
WINGs/WINGs/WUtil.h
+15 -19
View File
@@ -249,6 +249,9 @@ char* wgethomedir(void);
/* ---[ WINGs/proplist.c ]------------------------------------------------ */
/*
* Creates the directory path and all its parents.
*/
int wmkdirhier(const char *path);
int wrmdirhier(const char *path);
@@ -719,11 +722,13 @@ void WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
unsigned coalesceMask);
/* ---[ WINGs/proplist.c ]------------------------------------------------ */
/* Property Lists handling */
void WMPLSetCaseSensitive(Bool caseSensitive);
/* ---[ WINGs/proplist.c ]------------------------------------------------ */
WMPropList* WMCreatePLArray(WMPropList *elem, ...);
/* ---[ wutil-rs/src/prop_list.rs ]--------------------------------------- */
WMPropList* WMCreatePLString(const char *str);
@@ -731,9 +736,13 @@ WMPropList* WMCreatePLData(WMData *data);
WMPropList* WMCreatePLDataWithBytes(const unsigned char *bytes, unsigned int length);
WMPropList* WMCreatePLArray(WMPropList *elem, ...);
WMPropList* WMCreatePLArrayFromSlice(WMPropList *elems, unsigned int length);
WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value, ...);
WMPropList* WMCreateEmptyPLArray();
WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value);
WMPropList* WMCreateEmptyPLDictionary();
WMPropList* WMRetainPropList(WMPropList *plist);
@@ -782,14 +791,6 @@ Bool WMIsPropListEqualTo(WMPropList *plist, WMPropList *other);
/* Returns a reference. Do not free it! */
char* WMGetFromPLString(WMPropList *plist);
/* Returns a reference. Do not free it! */
WMData* WMGetFromPLData(WMPropList *plist);
/* Returns a reference. Do not free it! */
const unsigned char* WMGetPLDataBytes(WMPropList *plist);
int WMGetPLDataLength(WMPropList *plist);
/* Returns a reference. */
WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
@@ -797,14 +798,9 @@ WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
WMPropList* WMGetFromPLDictionary(WMPropList *plist, WMPropList *key);
/* Returns a PropList array with all the dictionary keys. Release it when
* you're done. Keys in array are retained from the original dictionary
* not copied and need NOT to be released individually. */
* you're done. */
WMPropList* WMGetPLDictionaryKeys(WMPropList *plist);
/* Creates only the first level deep object. All the elements inside are
* retained from the original */
WMPropList* WMShallowCopyPropList(WMPropList *plist);
/* Makes a completely separate replica of the original proplist */
WMPropList* WMDeepCopyPropList(WMPropList *plist);
WINGs/proplist.c
+6 -1828
View File
File diff suppressed because it is too large Load Diff
WINGs/userdefaults.c
+2 -35
View File
@@ -46,39 +46,6 @@ static void synchronizeUserDefaults(void *foo);
#define UD_SYNC_INTERVAL 2000
#endif
const char *wusergnusteppath(void)
{
static const char subdir[] = "/" GSUSER_SUBDIR;
static char *path = NULL;
char *gspath;
char *h;
int pathlen;
if (path)
/* Value have been already computed, re-use it */
return path;
gspath = GETENV("WMAKER_USER_ROOT");
if (gspath) {
gspath = wexpandpath(gspath);
if (gspath) {
path = gspath;
return path;
}
wwarning(_("variable WMAKER_USER_ROOT defined with invalid path, not used"));
}
h = wgethomedir();
pathlen = strlen(h);
path = wmalloc(pathlen + sizeof(subdir));
strcpy(path, h);
strcpy(path + pathlen, subdir);
wfree(h);
return path;
}
const char *wuserdatapath(void)
{
static char *path = NULL;
@@ -330,7 +297,7 @@ WMUserDefaults *WMGetStandardUserDefaults(void)
/* terminate list */
defaults->searchList[2] = NULL;
defaults->searchListArray = WMCreatePLArray(NULL, NULL);
defaults->searchListArray = WMCreateEmptyPLArray();
i = 0;
while (defaults->searchList[i]) {
@@ -403,7 +370,7 @@ WMUserDefaults *WMGetDefaultsFromPath(const char *path)
/* terminate list */
defaults->searchList[1] = NULL;
defaults->searchListArray = WMCreatePLArray(NULL, NULL);
defaults->searchListArray = WMCreateEmptyPLArray();
i = 0;
while (defaults->searchList[i]) {
WPrefs.app/Appearance.c
+2 -2
View File
@@ -2228,7 +2228,7 @@ static void prepareForClose(_Panel * panel)
WMUserDefaults *udb = WMGetStandardUserDefaults();
int i;
textureList = WMCreatePLArray(NULL, NULL);
textureList = WMCreateEmptyPLArray();
/* store list of textures */
for (i = 8; i < WMGetListNumberOfRows(panel->texLs); i++) {
@@ -2250,7 +2250,7 @@ static void prepareForClose(_Panel * panel)
WMReleasePropList(textureList);
/* store list of colors */
textureList = WMCreatePLArray(NULL, NULL);
textureList = WMCreateEmptyPLArray();
for (i = 0; i < wlengthof(sample_colors); i++) {
WMColor *color;
char *str;
WPrefs.app/HotCornerShortcuts.c
+1 -1
View File
@@ -151,7 +151,7 @@ static void storeData(_Panel * panel)
SetIntegerForKey(WMGetSliderValue(panel->hceS), "HotCornerEdge");
list = WMCreatePLArray(NULL, NULL);
list = WMCreateEmptyPLArray();
for (i = 0; i < sizeof(panel->hcactionsT) / sizeof(WMTextField *); i++) {
str = WMGetTextFieldText(panel->hcactionsT[i]);
if (strlen(str) == 0)
WPrefs.app/Paths.c
+2 -2
View File
@@ -203,7 +203,7 @@ static void storeData(_Panel * panel)
int i;
char *p;
list = WMCreatePLArray(NULL, NULL);
list = WMCreateEmptyPLArray();
for (i = 0; i < WMGetListNumberOfRows(panel->icoL); i++) {
p = WMGetListItem(panel->icoL, i)->text;
tmp = WMCreatePLString(p);
@@ -211,7 +211,7 @@ static void storeData(_Panel * panel)
}
SetObjectForKey(list, "IconPath");
list = WMCreatePLArray(NULL, NULL);
list = WMCreateEmptyPLArray();
for (i = 0; i < WMGetListNumberOfRows(panel->pixL); i++) {
p = WMGetListItem(panel->pixL, i)->text;
tmp = WMCreatePLString(p);
WPrefs.app/WPrefs.c
+2 -2
View File
@@ -705,10 +705,10 @@ static void loadConfigurations(WMScreen * scr, WMWindow * mainw)
}
if (!db) {
db = WMCreatePLDictionary(NULL, NULL);
db = WMCreateEmptyPLDictionary();
}
if (!gdb) {
gdb = WMCreatePLDictionary(NULL, NULL);
gdb = WMCreateEmptyPLDictionary();
}
GlobalDB = gdb;
WPrefs.app/main.c
+6 -1
View File
@@ -153,7 +153,12 @@ int main(int argc, char **argv)
exit(0);
}
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
Initialize(scr);
src/appicon.c
+1 -1
View File
@@ -1360,7 +1360,7 @@ static void wApplicationSaveIconPathFor(const char *iconPath, const char *wm_ins
val = WMGetFromPLDictionary(adict, iconk);
} else {
/* no dictionary for app, so create one */
adict = WMCreatePLDictionary(NULL, NULL);
adict = WMCreateEmptyPLDictionary();
WMPutInPLDictionary(dict, key, adict);
WMReleasePropList(adict);
val = NULL;
src/defaults.c
+6 -1
View File
@@ -862,7 +862,12 @@ static void initDefaults(void)
unsigned int i;
WDefaultEntry *entry;
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
for (i = 0; i < wlengthof(optionList); i++) {
entry = &optionList[i];
src/dialog.c
+1 -1
View File
@@ -250,7 +250,7 @@ static void SaveHistory(WMArray * history, const char *filename)
int i;
WMPropList *plhistory;
plhistory = WMCreatePLArray(NULL);
plhistory = WMCreateEmptyPLArray();
for (i = 0; i < WMGetArrayItemCount(history); ++i)
WMAddToPLArray(plhistory, WMCreatePLString(WMGetFromArray(history, i)));
src/dock.c
+11 -9
View File
@@ -1603,11 +1603,13 @@ static WMPropList *make_icon_state(WAppIcon *btn)
snprintf(buffer, sizeof(buffer), "%hi,%hi", wAppIconGetXIndex(btn), wAppIconGetYIndex(btn));
position = WMCreatePLString(buffer);
node = WMCreatePLDictionary(dCommand, command,
dName, name,
dAutoLaunch, autolaunch,
dLock, lock,
dForced, forced, dBuggyApplication, buggy, dPosition, position, NULL);
node = WMCreatePLDictionary(dCommand, command);
WMPutInPLDictionary(node, dName, name);
WMPutInPLDictionary(node, dAutoLaunch, autolaunch);
WMPutInPLDictionary(node, dLock, lock);
WMPutInPLDictionary(node, dForced, forced);
WMPutInPLDictionary(node, dBuggyApplication, buggy);
WMPutInPLDictionary(node, dPosition, position);
WMReleasePropList(command);
WMReleasePropList(name);
WMReleasePropList(position);
@@ -1642,7 +1644,7 @@ static WMPropList *dockSaveState(WDock *dock)
WMPropList *value, *key;
char buffer[256];
list = WMCreatePLArray(NULL);
list = WMCreateEmptyPLArray();
for (i = (dock->type == WM_DOCK ? 0 : 1); i < dock->max_icons; i++) {
WAppIcon *btn = dock->icon_array[i];
@@ -1657,7 +1659,7 @@ static WMPropList *dockSaveState(WDock *dock)
}
}
dock_state = WMCreatePLDictionary(dApplications, list, NULL);
dock_state = WMCreatePLDictionary(dApplications, list);
if (dock->type == WM_DOCK) {
snprintf(buffer, sizeof(buffer), "Applications%i", dock->screen_ptr->scr_height);
@@ -5072,7 +5074,7 @@ static WMPropList *drawerSaveState(WDock *drawer)
ai = drawer->icon_array[0];
/* Store its name */
pstr = WMCreatePLString(wAppIconGetWmInstance(ai));
drawer_state = WMCreatePLDictionary(dName, pstr, NULL); /* we need this final NULL */
drawer_state = WMCreatePLDictionary(dName, pstr);
WMReleasePropList(pstr);
/* Store its position */
@@ -5114,7 +5116,7 @@ void wDrawersSaveState(WScreen *scr)
make_keys();
all_drawers = WMCreatePLArray(NULL);
all_drawers = WMCreateEmptyPLArray();
for (i=0, dc = scr->drawers;
i < scr->drawer_count;
i++, dc = dc->next) {
src/menu.c
+3 -2
View File
@@ -2309,7 +2309,8 @@ static void saveMenuInfo(WMPropList * dict, WMenu * menu, WMPropList * key)
snprintf(buffer, sizeof(buffer), "%i,%i", menu->frame_x, menu->frame_y);
value = WMCreatePLString(buffer);
list = WMCreatePLArray(value, NULL);
list = WMCreateEmptyPLArray();
WMAddToPLArray(list, value);
if (menu->flags.lowered)
WMAddToPLArray(list, WMCreatePLString("lowered"));
WMPutInPLDictionary(dict, key, list);
@@ -2322,7 +2323,7 @@ void wMenuSaveState(WScreen * scr)
WMPropList *menus, *key;
int save_menus = 0;
menus = WMCreatePLDictionary(NULL, NULL);
menus = WMCreateEmptyPLDictionary();
if (scr->switch_menu && scr->switch_menu->flags.buttoned) {
key = WMCreatePLString("SwitchMenu");
src/screen.c
+6 -3
View File
@@ -968,8 +968,6 @@ void wScreenSaveState(WScreen * scr)
old_state = scr->session_state;
scr->session_state = WMCreatePLDictionary(NULL, NULL);
WMPLSetCaseSensitive(True);
/* save dock state to file */
if (!wPreferences.flags.nodock) {
wDockSaveState(scr, old_state);
@@ -1009,8 +1007,13 @@ void wScreenSaveState(WScreen * scr)
WMPutInPLDictionary(scr->session_state, dWorkspace, foo);
}
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* clean up */
WMPLSetCaseSensitive(False);
/* WMPLSetCaseSensitive(False); */
wMenuSaveState(scr);
src/session.c
+22 -15
View File
@@ -241,14 +241,15 @@ static WMPropList *makeWindowState(WWindow * wwin, WApplication * wapp)
snprintf(buffer, sizeof(buffer), "%u", mask);
shortcut = WMCreatePLString(buffer);
win_state = WMCreatePLDictionary(sName, name,
sCommand, cmd,
sWorkspace, workspace,
sShaded, shaded,
sMiniaturized, miniaturized,
sMaximized, maximized,
sHidden, hidden,
sShortcutMask, shortcut, sGeometry, geometry, NULL);
win_state = WMCreatePLDictionary(sName, name);
WMPutInPLDictionary(win_state, sCommand, cmd);
WMPutInPLDictionary(win_state, sWorkspace, workspace);
WMPutInPLDictionary(win_state, sShaded, shaded);
WMPutInPLDictionary(win_state, sMiniaturized, miniaturized);
WMPutInPLDictionary(win_state, sMaximized, maximized);
WMPutInPLDictionary(win_state, sHidden, hidden);
WMPutInPLDictionary(win_state, sShortcutMask, shortcut);
WMPutInPLDictionary(win_state, sGeometry, geometry);
WMReleasePropList(name);
WMReleasePropList(cmd);
@@ -313,7 +314,7 @@ void wSessionSaveState(WScreen * scr)
return;
}
list = WMCreatePLArray(NULL);
list = WMCreateEmptyPLArray();
wapp_list = WMCreateArray(16);
@@ -487,8 +488,6 @@ void wSessionRestoreState(WScreen *scr)
if (!scr->session_state)
return;
WMPLSetCaseSensitive(True);
apps = WMGetFromPLDictionary(scr->session_state, sApplications);
if (!apps)
return;
@@ -579,8 +578,13 @@ void wSessionRestoreState(WScreen *scr)
if (class)
wfree(class);
}
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* clean up */
WMPLSetCaseSensitive(False);
/* WMPLSetCaseSensitive(False); */
}
void wSessionRestoreLastWorkspace(WScreen * scr)
@@ -594,8 +598,6 @@ void wSessionRestoreLastWorkspace(WScreen * scr)
if (!scr->session_state)
return;
WMPLSetCaseSensitive(True);
wks = WMGetFromPLDictionary(scr->session_state, sWorkspace);
if (!wks || !WMIsPLString(wks))
return;
@@ -605,8 +607,13 @@ void wSessionRestoreLastWorkspace(WScreen * scr)
if (!value)
return;
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* clean up */
WMPLSetCaseSensitive(False);
/* WMPLSetCaseSensitive(False); */
/* Get the workspace number for the workspace name */
w = wGetWorkspaceNumber(scr, value);
src/wdefaults.c
+32 -17
View File
@@ -174,15 +174,18 @@ static WMPropList *get_value_from_instanceclass(const char *value)
key = WMCreatePLString(value);
WMPLSetCaseSensitive(True);
if (w_global.domain.window_attr->dictionary)
val = key ? WMGetFromPLDictionary(w_global.domain.window_attr->dictionary, key) : NULL;
if (key)
WMReleasePropList(key);
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
return val;
}
@@ -219,8 +222,6 @@ void wDefaultFillAttributes(const char *instance, const char *class,
dn = get_value_from_instanceclass(instance);
dc = get_value_from_instanceclass(class);
WMPLSetCaseSensitive(True);
if ((w_global.domain.window_attr->dictionary) && (useGlobalDefault))
da = WMGetFromPLDictionary(w_global.domain.window_attr->dictionary, AnyWindow);
@@ -311,8 +312,13 @@ void wDefaultFillAttributes(const char *instance, const char *class,
APPLY_VAL(value, no_language_button, ANoLanguageButton);
#endif
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* clean up */
WMPLSetCaseSensitive(False);
/* WMPLSetCaseSensitive(False); */
}
static WMPropList *get_generic_value(const char *instance, const char *class,
@@ -322,8 +328,6 @@ static WMPropList *get_generic_value(const char *instance, const char *class,
value = NULL;
WMPLSetCaseSensitive(True);
/* Search the icon name using class and instance */
if (class && instance) {
char *buffer;
@@ -371,7 +375,12 @@ static WMPropList *get_generic_value(const char *instance, const char *class,
value = WMGetFromPLDictionary(dict, option);
}
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
return value;
}
@@ -545,15 +554,13 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
int same = 0;
if (!dict) {
dict = WMCreatePLDictionary(NULL, NULL);
dict = WMCreateEmptyPLDictionary();
if (dict)
db->dictionary = dict;
else
return;
}
WMPLSetCaseSensitive(True);
if (instance && class) {
char *buffer;
@@ -570,7 +577,7 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
if (file) {
value = WMCreatePLString(file);
icon_value = WMCreatePLDictionary(AIcon, value, NULL);
icon_value = WMCreatePLDictionary(AIcon, value);
WMReleasePropList(value);
def_win = WMGetFromPLDictionary(dict, AnyWindow);
@@ -600,7 +607,12 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
if (icon_value)
WMReleasePropList(icon_value);
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
}
void wDefaultPurgeInfo(const char *instance, const char *class)
@@ -612,8 +624,6 @@ void wDefaultPurgeInfo(const char *instance, const char *class)
init_wdefaults();
}
WMPLSetCaseSensitive(True);
buffer = wmalloc(strlen(class) + strlen(instance) + 2);
sprintf(buffer, "%s.%s", instance, class);
key = WMCreatePLString(buffer);
@@ -631,7 +641,12 @@ void wDefaultPurgeInfo(const char *instance, const char *class)
wfree(buffer);
WMReleasePropList(key);
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
}
/* --------------------------- Local ----------------------- */
src/winspector.c
+9 -6
View File
@@ -597,7 +597,7 @@ static void saveSettings(WMWidget *button, void *client_data)
dict = db->dictionary;
if (!dict) {
dict = WMCreatePLDictionary(NULL, NULL);
dict = WMCreateEmptyPLDictionary();
if (dict) {
db->dictionary = dict;
} else {
@@ -609,10 +609,8 @@ static void saveSettings(WMWidget *button, void *client_data)
if (showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD) < 0)
return;
WMPLSetCaseSensitive(True);
winDic = WMCreatePLDictionary(NULL, NULL);
appDic = WMCreatePLDictionary(NULL, NULL);
winDic = WMCreateEmptyPLDictionary();
appDic = WMCreateEmptyPLDictionary();
/* Save the icon info */
/* The flag "Ignore client suplied icon is not selected" */
@@ -709,8 +707,13 @@ static void saveSettings(WMWidget *button, void *client_data)
UpdateDomainFile(db);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* clean up */
WMPLSetCaseSensitive(False);
/* WMPLSetCaseSensitive(False); */
}
static void applySettings(WMWidget *button, void *client_data)
src/workspace.c
+2 -2
View File
@@ -852,10 +852,10 @@ void wWorkspaceSaveState(WScreen * scr, WMPropList * old_state)
make_keys();
old_wks_state = WMGetFromPLDictionary(old_state, dWorkspaces);
parr = WMCreatePLArray(NULL);
parr = WMCreateEmptyPLArray();
for (i = 0; i < scr->workspace_count; i++) {
pstr = WMCreatePLString(scr->workspaces[i]->name);
wks_state = WMCreatePLDictionary(dName, pstr, NULL);
wks_state = WMCreatePLDictionary(dName, pstr);
WMReleasePropList(pstr);
if (!wPreferences.flags.noclip) {
pstr = wClipSaveWorkspaceState(scr, i);
util/convertfonts.c
+6 -1
View File
@@ -131,7 +131,12 @@ int main(int argc, char **argv)
/* this contradicts big time with getstyle */
setlocale(LC_ALL, "");
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
style = WMReadPropListFromFile(file);
if (!style) {
util/geticonset.c
+1 -1
View File
@@ -109,7 +109,7 @@ int main(int argc, char **argv)
if (window_attrs && WMIsPLDictionary(window_attrs)) {
icon_value = WMGetFromPLDictionary(window_attrs, icon_key);
if (icon_value) {
icondic = WMCreatePLDictionary(icon_key, icon_value, NULL);
icondic = WMCreatePLDictionary(icon_key, icon_value);
WMPutInPLDictionary(iconset, window_name, icondic);
}
}
util/getstyle.c
+7 -2
View File
@@ -337,7 +337,12 @@ int main(int argc, char **argv)
return 1;
}
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
path = wdefaultspathfordomain("WindowMaker");
@@ -357,7 +362,7 @@ int main(int argc, char **argv)
prop = val;
}
style = WMCreatePLDictionary(NULL, NULL);
style = WMCreateEmptyPLDictionary();
for (i = 0; options[i] != NULL; i++) {
key = WMCreatePLString(options[i]);
util/setstyle.c
+6 -1
View File
@@ -427,7 +427,12 @@ int main(int argc, char **argv)
file = argv[0];
WMPLSetCaseSensitive(False);
/*
* Rust rewrite note: this API surface has been removed, but we leave in
* a record of where it was invoked to set a value other than the
* default, in case it helps to track down bugs in the future.
*/
/* WMPLSetCaseSensitive(False); */
path = wdefaultspathfordomain("WindowMaker");
util/wdwrite.c
+1 -1
View File
@@ -103,7 +103,7 @@ int main(int argc, char **argv)
dict = WMReadPropListFromFile(path);
if (!dict) {
dict = WMCreatePLDictionary(key, value, NULL);
dict = WMCreatePLDictionary(key, value);
} else {
WMPutInPLDictionary(dict, key, value);
}
util/wmsetbg.c
+2 -2
View File
@@ -1199,14 +1199,14 @@ static void changeTextureForWorkspace(const char *domain, char *texture, int wor
array = getValueForKey("WindowMaker", "WorkspaceSpecificBack");
if (!array) {
array = WMCreatePLArray(NULL, NULL);
array = WMCreateEmptyPLArray();
}
j = WMGetPropListItemCount(array);
if (workspace >= j) {
WMPropList *empty;
empty = WMCreatePLArray(NULL, NULL);
empty = WMCreateEmptyPLArray();
while (j++ < workspace - 1) {
WMAddToPLArray(array, empty);
wutil-rs/Cargo.toml
+5
View File
@@ -8,3 +8,8 @@ crate-type = ["staticlib"]
[build-dependencies]
cc = "1.0"
[dependencies]
atomic-write-file = "0.3"
nom = "8.0"
nom-language = "0.1"
wutil-rs/Makefile.am
+4 -1
View File
@@ -2,9 +2,12 @@ AUTOMAKE_OPTIONS =
RUST_SOURCES = \
src/array.rs \
src/defines.c \
src/defines.rs \
src/find_file.rs \
src/lib.rs \
src/memory.rs
src/memory.rs \
src/prop_list.rs
RUST_EXTRA = \
Cargo.lock \
wutil-rs/src/data.rs
+13
View File
@@ -19,6 +19,19 @@ pub enum Format {
/// Rust.
pub struct Data(Rc<RefCell<Inner>>);
impl Data {
/// Runs `f` on a borrow of `self`'s data, returning whatever `f` does.
///
/// This is provided because the internal structure of `Data` does not make
/// it easy to borrow its contents directly. As we migrate away from the
/// original C interfaces to WINGs data structures, we may be able to
/// provide a direct borrow, which would make this method obsolete. (That
/// would be a good thing.)
pub fn with_bytes<R>(&self, f: impl FnOnce(&[u8]) -> R) -> R {
f(&self.0.borrow().bytes)
}
}
struct Inner {
bytes: Vec<u8>,
format: Format,
wutil-rs/src/find_file.rs
+186 -10
View File
@@ -12,21 +12,34 @@
//! whose first component is `~` will still be resolved relatively to the
//! current user's home directory.
//!
//! Keep in mind that these utilities are not strictly correct as originally
//! designed: a file path that appears valid when it is checked in a subroutine
//! may become invalid if the file is deleted between when the path is checked
//! and when downstream code attempts to open the file. A better design would
//! open the file and return a live file pointer instead of simply returning a
//! path that is likely to work. Future work should redesign this module to
//! avoid this issue.
//! ## Rust rewrite notes
//!
//! Many of these utilities are not strictly correct as originally designed: a
//! file path that appears valid when it is checked in a subroutine may become
//! invalid if the file is deleted between when the path is checked and when
//! downstream code attempts to open the file. (This is a TOCTOU issue.) A
//! better design would open the file and return a live file pointer instead of
//! simply returning a path that is likely to work. Future work should redesign
//! this module to avoid this issue.
use crate::defines;
use std::{
env,
ffi::OsStr,
ffi::{CStr, OsStr},
fs::File,
io,
path::{Component, Path, PathBuf},
};
/// Tries to interpret `s` as a UTF-8 path. Returns `None` if decoding `s`
/// fails.
pub fn path_from_cstr(s: &CStr) -> Option<PathBuf> {
String::from_utf8(s.to_bytes().iter().copied().collect())
.ok()
.map(|p| PathBuf::from(p))
}
/// If `file` is an absolute path can be opened, returns that path. Paths
/// starting with `~` are treated as absolute, and the user's home directory is
/// substituted for `~` (so `~/foo` becomes `(users's home directory)/foo`). If
@@ -78,13 +91,116 @@ pub fn in_paths<'a>(paths: impl Iterator<Item = &'a Path>, file: &Path) -> Optio
None
}
/// Returns the root path that user data will be stored at. This is probably
/// `$HOME/GNUstep` (or some other default if a different path was specified for
/// [`defaults::gsuser_subdir`] at compilation time), unless the environment
/// variable `WMAKER_USER_ROOT` is defined, in which case it's that.
pub fn user_gnustep_path() -> Option<PathBuf> {
match env::var("WMAKER_USER_ROOT") {
Ok(path) => {
if let Some(path) = absolute(&PathBuf::from(&path)) {
return Some(path);
}
}
Err(env::VarError::NotUnicode(_)) => {
// TODO: warn.
}
Err(env::VarError::NotPresent) => (),
}
match (env::home_dir(), defines::gsuser_subdir()) {
(None, _) => {
// TODO: warn.
None
}
(Some(mut parent), Some(subdir)) => {
parent.push(subdir);
Some(parent)
}
(Some(_), None) => {
// TODO: warn.
None
}
}
}
/// Creates the directory at `p` and all of its parents, respecting the current
/// umask as much as possible. Only allows creation of paths under
/// [`user_gnustep_path`].
pub fn create_path_hierarchy<P: AsRef<Path>>(p: P) -> io::Result<()> {
let p = p.as_ref();
let Ok(canonical_p) = p.canonicalize() else {
return Err(io::Error::other("cannot canonicalize requested path"));
};
let Some(wmaker_user_root) = user_gnustep_path() else {
return Err(io::Error::other("cannot determine WMAKER_USER_ROOT. try setting the environment variable WMAKER_USER_ROOT."));
};
let Ok(wmaker_user_root) = Path::new(&wmaker_user_root).canonicalize() else {
return Err(io::Error::other(
"cannot canonicalize path for WMAKER_USER_ROOT",
));
};
if !canonical_p.starts_with(&wmaker_user_root) {
return Err(io::Error::other(
"requested path is not under WMAKER_USER_ROOT",
));
}
create_path_hierarchy_impl(&canonical_p)
}
/// Removes the file at `p` (and anything under it, if `p` is a directory). Only
/// allows deletion of files under [`user_gnustep_path`]`/Defaults` or
/// [`user_gnustep_path`]`/Library`.
pub fn remove_path_hierarchy<P: AsRef<Path>>(p: P) -> io::Result<()> {
let p = p.as_ref();
let Ok(canonical_p) = p.canonicalize() else {
return Err(io::Error::other("cannot canonicalize requested path"));
};
let Some(wmaker_user_root) = user_gnustep_path() else {
return Err(io::Error::other("cannot determine WMAKER_USER_ROOT. try setting the environment variable WMAKER_USER_ROOT."));
};
let Ok(wmaker_user_root) = Path::new(&wmaker_user_root).canonicalize() else {
return Err(io::Error::other(
"cannot canonicalize path for WMAKER_USER_ROOT",
));
};
let mut defaults = wmaker_user_root.clone();
defaults.push("Defaults");
let mut library = wmaker_user_root;
library.push("Library");
if !canonical_p.starts_with(&defaults) && !canonical_p.starts_with(&library) {
return Err(io::Error::other(
"requested path is not under WMAKER_USER_ROOT/Defaults or WMAKER_USER_ROOT/Library",
));
}
std::fs::remove_dir_all(canonical_p)
}
#[cfg(target_family = "unix")]
fn create_path_hierarchy_impl(p: &Path) -> io::Result<()> {
use std::os::unix::fs::DirBuilderExt;
std::fs::DirBuilder::new()
.recursive(true)
.mode(0o777)
.create(p)
}
#[cfg(not(target_family = "unix"))]
fn create_path_hierarchy_impl(p: &Path) -> io::Result<()> {
std::fs::DirBuilder::new().recursive(true).create(p)
}
pub mod ffi {
use super::{absolute, in_paths};
use super::{absolute, create_path_hierarchy, in_paths, path_from_cstr, remove_path_hierarchy, user_gnustep_path};
use crate::memory::alloc_bytes;
use std::{
env,
ffi::{CStr, OsStr, c_char, c_int},
ffi::{c_char, c_int, CStr, OsStr},
iter,
os::unix::ffi::OsStrExt,
path::{Path, PathBuf},
@@ -218,4 +334,64 @@ pub mod ffi {
return -1;
}
}
/// Delegates to [`create_path_hierarchy`].
///
/// ## Rust rewrite notes
///
/// The original C implementation of this function stripped the last path
/// component if it did not end in a `'/'` (i.e., it looked like a regular
/// file instead of a directory). This behavior does not appear to be relied
/// upon by any existing callers except for `WMWritePropListToFile`, which
/// has been rewritten, and it is not super portable (and annoying because
/// it adds weird edge cases). So each component of `path` is treated as a
/// directory to be made.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn wmkdirhier(path: *const c_char) -> c_int {
if path.is_null() {
return 0;
}
let path = unsafe { CStr::from_ptr(path) };
let Some(path) = path_from_cstr(path) else {
return 0;
};
if create_path_hierarchy(path).is_ok() {
return 1;
} else {
return 0;
}
}
/// Delegates to [`remove_path_hierarchy`].
#[unsafe(no_mangle)]
pub unsafe extern "C" fn wrmdirhier(path: *const c_char) -> c_int {
if path.is_null() {
return 0;
}
let path = unsafe { CStr::from_ptr(path) };
let Some(path) = path_from_cstr(path) else {
return 0;
};
if remove_path_hierarchy(path).is_ok() {
return 1;
} else {
return 0;
}
}
/// Delegates to [`user_gnustep_path`]. Returns the path, which must be The
/// returned value must be freed with [`crate::memory::free_bytes`] or
/// [`crate::memory::ffi::wfree`], path cannot be determined.
///
/// ## Rust rewrite notes
///
/// This was originally in `WINGs/userdefaults.c`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn wusergnusteppath() -> *mut c_char {
if let Some(path) = user_gnustep_path() {
to_c_str(&path)
} else {
ptr::null_mut()
}
}
}
wutil-rs/src/lib.rs
+1
View File
@@ -3,3 +3,4 @@ pub mod data;
pub mod defines;
pub mod find_file;
pub mod memory;
pub mod prop_list;
wutil-rs/src/prop_list.rs
+871
View File
@@ -0,0 +1,871 @@
//! Property lists: shared, tree-structured data.
//!
//! ## Rust rewrite notes
//!
//! This implementation should be good enough to facilitate migrating from C to
//! Rust and trasitioning away from using property lists everywhere instead of
//! proper structs. `PropList`s are a really cool general-purpose tool for
//! attaching data to objects and persisting it to disk. But in Rust, it is
//! easier to use proper structs with typed fields and appropriate `#[derive]`
//! declarations to generate code for serialization and deserialization
//! (presumably using Serde).
//!
//! As code that uses `PropList`s is rewritte in Rust, we should work on
//! migrating away from use of `PropList`s. Objects whose fields that can be
//! statically typed should be represented as structs. They may still be
//! persisted by cramming them into `PropList`s and writing those to disk, but
//! it would be better still to implement Serde-based serialization to and from
//! the property list format.
//!
//! The `PropList` implementation itself can also be improved substantially. See
//! [`PropList`] for thoughts on this.
use atomic_write_file::unix::OpenOptionsExt;
use std::{
cell::RefCell,
collections::{hash_map, HashMap},
ffi::{CString, OsStr, OsString},
fmt, hash,
io::{self, BufWriter, Write},
path::Path,
process::Command,
ptr,
rc::Rc,
};
use crate::find_file;
pub mod parser;
pub mod writer;
/// Payload of a [`PropList`].
#[derive(Eq, PartialEq)]
pub enum Node {
/// Text data. This is UTF-8 encoded and null-safe.
///
/// ## Rust rewrite notes
///
/// It would be better for this to be a `String`, but the C interface
/// requires borrows of C-style strings.
String(CString),
/// Binary data.
Data(Vec<u8>),
/// Array of child `PropList`s.
Array(Vec<PropList>),
/// `PropList`-keyed table of child `PropList`s. Keys should only have
/// `Node::String` or `Node::Data` payloads, although there is almost no
/// enforcement of this.
Dictionary(HashMap<PropList, PropList>),
}
impl hash::Hash for Node {
fn hash<H: hash::Hasher>(&self, h: &mut H) {
match self {
Node::String(s) => s.hash(h),
Node::Data(d) => d.hash(h),
Node::Array(a) => {
for p in a {
p.hash(h);
}
}
Node::Dictionary(d) => {
for (k, v) in d {
k.hash(h);
v.hash(h);
}
}
}
}
}
impl fmt::Debug for Node {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"{}",
writer::Display {
inline: writer::Inline::Soft,
clear_left: false,
indentation: 0,
increment: 2,
node: self,
}
)
}
}
fn merge_shallow(dest: PropList, source: PropList) {
if ptr::eq(dest.0.as_ref(), source.0.as_ref()) {
return;
}
let Node::Dictionary(ref mut dest_items) = *dest.0.borrow_mut() else {
return;
};
let Node::Dictionary(ref source) = *source.0.borrow() else {
return;
};
for (k, v) in source {
if ptr::eq(dest.0.as_ptr(), k.0.as_ptr()) {
// Don't borrow k if it is already borrowed as dest.
continue;
}
dest_items.insert(k.clone(), v.clone());
}
}
fn merge_deep(dest: PropList, source: PropList) {
if ptr::eq(dest.0.as_ptr(), source.0.as_ptr()) {
return;
}
let Node::Dictionary(dest_items) = &mut *dest.0.borrow_mut() else {
return;
};
let Node::Dictionary(source_items) = &*source.0.borrow() else {
return;
};
for (key, value) in source_items {
if key.0.try_borrow().is_err() || value.0.try_borrow().is_err() {
// Something has already borrowed key or value. This may happen if
// source contains pointers that are also in dest, or if dest is
// cyclic. This is bad, but we just bail out.
continue;
}
match dest_items.entry(key.clone()) {
hash_map::Entry::Vacant(v) => {
// Dest has nothing at key. Insert value from source.
v.insert(value.clone());
}
hash_map::Entry::Occupied(mut o) => {
let recur = match *o.get().0.borrow() {
Node::Dictionary(_) => true,
_ => false,
};
if recur {
// dest[key] is a dictionary. Recur on dest[key] and value from source.
merge_deep(o.get().clone(), value.clone());
} else {
// dest[key] is not a dictionary. Overwrite with value from source.
o.insert(value.clone());
}
}
}
}
}
fn subtract_shallow(dest: PropList, source: PropList) {
if ptr::eq(dest.0.as_ptr(), source.0.as_ptr()) {
if let Node::Dictionary(ref mut items) = *dest.0.borrow_mut() {
items.clear();
}
return;
}
let Node::Dictionary(ref mut dest_items) = *dest.0.borrow_mut() else {
return;
};
let Node::Dictionary(ref source_items) = *source.0.borrow() else {
return;
};
for (k, v) in source_items.iter() {
if ptr::eq(dest.0.as_ptr(), k.0.as_ptr()) {
continue;
}
if let hash_map::Entry::Occupied(o) = dest_items.entry(k.clone()) {
if o.get() == v {
o.remove();
}
}
}
}
fn subtract_deep(dest: PropList, source: PropList) {
if ptr::eq(dest.0.as_ptr(), source.0.as_ptr()) {
if let Node::Dictionary(ref mut items) = *dest.0.borrow_mut() {
items.clear();
}
return;
}
let Node::Dictionary(ref mut dest_items) = *dest.0.borrow_mut() else {
return;
};
let Node::Dictionary(ref source_items) = *source.0.borrow() else {
return;
};
for (k, v) in source_items.iter() {
if ptr::eq(dest.0.as_ptr(), k.0.as_ptr()) {
continue;
}
if let hash_map::Entry::Occupied(o) = dest_items.entry(k.clone()) {
if o.get() == v {
o.remove();
continue;
}
let recur = match (&*o.get().0.borrow(), &*v.0.borrow()) {
(Node::Dictionary(_), Node::Dictionary(_)) => true,
_ => false,
};
if recur {
subtract_deep(o.get().clone(), v.clone());
}
}
}
}
/// Data graph with convenient (de)serialization to/from the [property
/// list](https://en.wikipedia.org/wiki/Property_list) format.
///
/// ## Rust rewrite notes
///
/// The original WUtils `PropList` was a reference-counted pointer, so it
/// supported shallow copy and shared-memory semantics that we have continued to
/// try to support in the Rust implementation. As a result, `PropList` is a thin
/// wrapper around an `Rc<RefCell<Node>>`. There are several reasons why this is
/// probably unnecessary and something we should migrate away from:
///
/// * It allows for the creation of non-tree structures, which was probably
/// never intended. (A degenerate `PropList` could even have itself as a child.)
/// * It complicates recursive operations on `PropList`s (equality checks,
/// merging, or taking differences) because a given `PropList` may occur
/// multiple times when traversing two `PropList`s, but `Rc` only allows it to be
/// mutably borrowed once.
/// * Allowing subtrees to be shared between two different `PropList`s
/// may lead to spooky action at a distance and may not actually be taken
/// advantage of by any client code.
///
/// As client code is migrated into Rust, it would be great to move away from
/// this implementation to a simpler one. As discussed in the module-level
/// rewrite notes, we may even be able to do away with `PropList` itself
/// (perhaps in favor of using Serde to write to and from property list files on
/// disk).
#[derive(Clone)]
pub struct PropList(Rc<RefCell<Node>>);
impl PropList {
pub fn new(node: Node) -> Self {
PropList(Rc::new(RefCell::new(node)))
}
/// Reads `r` to the end and tries to parse it into a `PropList`.
pub fn from_file<P: AsRef<Path>>(path: P) -> Result<PropList, String> {
let path = path.as_ref().to_path_buf();
let buf = std::fs::read_to_string(&path).map_err(|e| format!("{}", e))?;
parser::from_str(buf.as_str())
}
// Runs `command` and tries to parse a PropList from its standard output.
pub fn from_command<S: AsRef<OsStr>>(command: S) -> Result<PropList, String> {
let command: OsString = command.as_ref().to_os_string();
let output = Command::new("/bin/sh")
.arg("-c")
.arg(command.clone())
.output()
.map_err(|e| format!("{}", e))?;
let output = str::from_utf8(&output.stdout).map_err(|e| format!("{}", e))?;
parser::from_str(&output)
}
pub fn display_indented<'s>(&'s self) -> impl fmt::Display + 's {
writer::Display {
inline: writer::Inline::Soft,
clear_left: false,
indentation: 0,
increment: 2,
node: self.0.borrow(),
}
}
pub fn display_unindented<'s>(&'s self) -> impl fmt::Display + 's {
writer::Display {
inline: writer::Inline::Hard,
clear_left: false,
indentation: 0,
increment: 0,
node: self.0.borrow(),
}
}
}
impl Eq for PropList {}
impl PartialEq for PropList {
fn eq(&self, other: &Self) -> bool {
*self.0.borrow() == *other.0.borrow()
}
}
impl hash::Hash for PropList {
fn hash<H: hash::Hasher>(&self, h: &mut H) {
self.0.borrow().hash(h)
}
}
impl fmt::Debug for PropList {
fn fmt(&self, out: &mut fmt::Formatter) -> fmt::Result {
write!(out, "{:?}", self.0.borrow())?;
Ok(())
}
}
impl PropList {
pub fn deep_clone(&self) -> Self {
match &*self.0.borrow() {
Node::String(s) => PropList::new(Node::String(s.clone())),
Node::Data(d) => PropList::new(Node::Data(d.clone())),
Node::Array(items) => {
PropList::new(Node::Array(items.iter().map(|x| x.deep_clone()).collect()))
}
Node::Dictionary(items) => PropList::new(Node::Dictionary(
items
.iter()
.map(|(k, v)| (k.deep_clone(), v.deep_clone()))
.collect(),
)),
}
}
/// Atomically serialize this `PropList` to `path`, creating any necessary
/// parent directories.
///
/// `path` is written to atomically: either the serialized `PropList` will
/// be completely written to `path`, or the operation will fail and any
/// existing file at `path` will not be modified.
///
/// ## Rust rewrite notes
///
/// As originally noted in `proplist.c`, a Coverity security bug report
/// flagged the need to preserve the permissions on the file being written
/// to. This should be respected in the rewritten code under Unix-like
/// operataing systems.
pub fn write_to_file<P: AsRef<Path>>(&self, path: &P) -> io::Result<()> {
self.write_to_file_impl(path.as_ref())
}
fn write_to_file_impl(&self, path: &Path) -> io::Result<()> {
if let Some(parent) = path.parent() {
find_file::create_path_hierarchy(parent)?;
}
let file = atomic_write_file::AtomicWriteFile::options()
.preserve_mode(true)
.open(&path)?;
let mut out = BufWriter::new(file);
writeln!(&mut out, "{}", self.display_indented())?;
out.into_inner()?.commit()
}
}
pub mod ffi {
use crate::{data::Data, find_file::path_from_cstr};
use super::{
merge_deep, merge_shallow, parser, subtract_deep, subtract_shallow, Node, PropList,
};
use std::{
collections::HashMap, ffi::{c_char, c_int, c_uchar, c_uint, CStr, CString, OsString}, ptr, str::FromStr
};
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreatePLString(s: *const c_char) -> *mut PropList {
if s.is_null() {
return ptr::null_mut();
}
let s = unsafe { CStr::from_ptr(s) };
Box::leak(Box::new(PropList::new(Node::String(s.into()))))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreatePLData(data: *mut Data) -> *mut PropList {
if data.is_null() {
return ptr::null_mut();
}
let data = unsafe { &*data };
data.with_bytes(|b| Box::leak(Box::new(PropList::new(Node::Data(Vec::from(b))))))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreatePLDataWithBytes(
bytes: *const c_uchar,
length: c_uint,
) -> *mut PropList {
if bytes.is_null() {
return ptr::null_mut();
}
let bytes = unsafe { &*ptr::slice_from_raw_parts(bytes.cast::<u8>(), length as usize) };
Box::leak(Box::new(PropList::new(Node::Data(Vec::from(bytes)))))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreatePLArrayFromSlice(
elems: *mut PropList,
length: c_uint,
) -> *mut PropList {
if elems.is_null() {
return ptr::null_mut();
}
let elems = unsafe { &*ptr::slice_from_raw_parts(elems, length as usize) };
Box::leak(Box::new(PropList::new(Node::Array(
elems.iter().cloned().collect(),
))))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreateEmptyPLArray() -> *mut PropList {
Box::leak(Box::new(PropList::new(Node::Array(Vec::new()))))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreatePLDictionary(
key: *mut PropList,
value: *mut PropList,
) -> *mut PropList {
if key.is_null() || value.is_null() {
return Box::leak(Box::new(PropList::new(Node::Dictionary(HashMap::new()))));
}
let key = unsafe { (*key).clone() };
let value = unsafe { (*value).clone() };
Box::leak(Box::new(PropList::new(Node::Dictionary(
[(key, value)].into(),
))))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreateEmptyPLDictionary() -> *mut PropList {
Box::leak(Box::new(PropList::new(Node::Dictionary(HashMap::new()))))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMRetainPropList(plist: *mut PropList) -> *mut PropList {
if plist.is_null() {
return ptr::null_mut();
}
unsafe { Box::leak(Box::new((*plist).clone())) }
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMReleasePropList(plist: *mut PropList) {
if plist.is_null() {
return;
}
let _ = unsafe { ptr::read(plist) };
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMInsertInPLArray(
plist: *mut PropList,
index: c_int,
item: *mut PropList,
) {
if plist.is_null() || index < 0 || item.is_null() {
return;
}
let plist = unsafe { &mut *plist };
if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
let item = unsafe { (*item).clone() };
items.insert(index as usize, item);
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMAddToPLArray(plist: *mut PropList, item: *mut PropList) {
if plist.is_null() || item.is_null() {
return;
}
let plist = unsafe { &mut *plist };
if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
let item = unsafe { (*item).clone() };
items.push(item);
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMDeleteFromPLArray(plist: *mut PropList, index: c_int) {
if plist.is_null() || index < 0 {
return;
}
let plist = unsafe { &mut *plist };
if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
items.remove(index as usize);
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMRemoveFromPLArray(plist: *mut PropList, item: *mut PropList) {
if plist.is_null() || item.is_null() {
return;
}
let plist = unsafe { &mut *plist };
let item = unsafe { &*item };
if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
if let Some((i, _)) = items.iter().enumerate().find(|(_, x)| *x == item) {
items.remove(i);
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMPutInPLDictionary(
plist: *mut PropList,
key: *mut PropList,
value: *mut PropList,
) {
if plist.is_null() || key.is_null() || value.is_null() {
return;
}
let plist = unsafe { &mut *plist };
if let Node::Dictionary(ref mut items) = *plist.0.borrow_mut() {
let key = unsafe { (*key).clone() };
let value = unsafe { (*value).clone() };
items.insert(key, value);
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMRemoveFromPLDictionary(plist: *mut PropList, key: *mut PropList) {
if plist.is_null() || key.is_null() {
return;
}
let plist = unsafe { &mut *plist };
let key = unsafe { &*key };
if let Node::Dictionary(ref mut items) = *plist.0.borrow_mut() {
items.remove(key);
}
}
/// If `dest` and `source` are both dictionaries, overwrites entries in
/// `dest` with corresponding entries in `source`.
///
/// If `recursive` is non-zero, this is done recursively for values in
/// `dest` and `source` that are both dictionaries.
///
/// ## Rust rewrite notes
///
/// This operation is used a few times. It may be worth keeping around
/// longer-term, although it might be hard to express if we do transition
/// away from `PropList`s to statically typed struct trees.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMMergePLDictionaries(
dest: *mut PropList,
source: *mut PropList,
recursive: c_int,
) -> *mut PropList {
if dest.is_null() || ptr::eq(dest, source) || source.is_null() {
return dest;
}
let dest = unsafe { (*dest).clone() };
let source = unsafe { (*source).clone() };
if recursive == 0 {
merge_shallow(dest.clone(), source);
} else {
merge_deep(dest.clone(), source);
}
return Box::leak(Box::new(dest));
}
/// If `dest` and `source` are both dictionaries, removes from `dest` any
/// `(k, v)` pairs where `dest[k] == source[k]`.
///
/// If `recursive` is non-zero, this is done recursively over subtrees of
/// `dest` and `source` when both `dest` and `source` are dictionaries for
/// keys of `source` that are also keys of `dest`.
///
/// ## Rust rewrite notes
///
/// This operation is only used in one place. It may be better to implement
/// this behavior as a one-off closer to where it is used, or with a
/// different API differently (e.g., as a function of a more general
/// proplist diff).
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMSubtractPLDictionaries(
dest: *mut PropList,
source: *mut PropList,
recursive: c_int,
) -> *mut PropList {
if dest.is_null() {
return ptr::null_mut();
}
if source.is_null() {
return dest;
}
let dest = unsafe { (*dest).clone() };
let source = unsafe { (*source).clone() };
if recursive == 0 {
subtract_shallow(dest.clone(), source);
} else {
subtract_deep(dest.clone(), source);
}
Box::leak(Box::new(dest))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMGetPropListItemCount(plist: *mut PropList) -> c_int {
if plist.is_null() {
return 0;
}
let plist = unsafe { &*plist };
match &*plist.0.borrow() {
Node::Array(xs) => xs.len() as c_int,
Node::Dictionary(xs) => xs.len() as c_int,
_ => 0,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMIsPLString(plist: *mut PropList) -> c_int {
if plist.is_null() {
return 0;
}
let plist = unsafe { &*plist };
match &*plist.0.borrow() {
Node::String(_) => 1,
_ => 0,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMIsPLData(plist: *mut PropList) -> c_int {
if plist.is_null() {
return 0;
}
let plist = unsafe { &*plist };
match &*plist.0.borrow() {
Node::Data(_) => 1,
_ => 0,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMIsPLArray(plist: *mut PropList) -> c_int {
if plist.is_null() {
return 0;
}
let plist = unsafe { &*plist };
match &*plist.0.borrow() {
Node::Array(_) => 1,
_ => 0,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMIsPLDictionary(plist: *mut PropList) -> c_int {
if plist.is_null() {
return 0;
}
let plist = unsafe { &*plist };
match &*plist.0.borrow() {
Node::Dictionary(_) => 1,
_ => 0,
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMIsPropListEqualTo(a: *mut PropList, b: *mut PropList) -> c_int {
if ptr::eq(a, b) {
return 1;
}
if a.is_null() {
return 0;
}
let a = unsafe { &*a };
let b = unsafe { &*b };
if a == b {
1
} else {
0
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMGetFromPLString(plist: *mut PropList) -> *const c_char {
if plist.is_null() {
return ptr::null_mut();
}
let plist = unsafe { &*plist };
if let Node::String(ref s) = *plist.0.borrow() {
s.as_ref().as_ptr().cast::<c_char>()
} else {
ptr::null()
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMGetFromPLArray(plist: *mut PropList, index: c_int) -> *mut PropList {
if plist.is_null() || index < 0 {
return ptr::null_mut();
}
let plist = unsafe { &*plist };
if let Node::Array(ref items) = *plist.0.borrow() {
Box::leak(Box::new(items[index as usize].clone()))
} else {
ptr::null_mut()
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMGetFromPLDictionary(plist: *mut PropList, key: *mut PropList) -> *mut PropList {
if plist.is_null() || key.is_null() {
return ptr::null_mut();
}
let plist = unsafe { &*plist };
let key = unsafe { &*key };
if let Node::Dictionary(ref items) = *plist.0.borrow() {
if let Some(item) = items.get(key) {
return Box::leak(Box::new(item.clone()));
}
}
ptr::null_mut()
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMGetPLDictionaryKeys(plist: *mut PropList) -> *mut PropList {
if plist.is_null() {
return ptr::null_mut();
}
let plist = unsafe { &*plist };
if let Node::Dictionary(ref items) = *plist.0.borrow() {
return Box::leak(Box::new(PropList::new(Node::Array(items.keys().cloned().collect()))));
}
ptr::null_mut()
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMDeepCopyPropList(plist: *mut PropList) -> *mut PropList {
if plist.is_null() {
return ptr::null_mut();
}
let plist = unsafe { &*plist };
Box::leak(Box::new(plist.deep_clone()))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMCreatePropListFromDescription(desc: *const c_char) -> *mut PropList {
if desc.is_null() {
return ptr::null_mut();
}
let desc = unsafe { CStr::from_ptr(desc) };
let Ok(desc) = desc.to_str() else {
return ptr::null_mut();
};
match parser::from_str(desc) {
Ok(plist) => Box::leak(Box::new(plist)),
Err(_) => ptr::null_mut(),
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMGetPropListDescription(
plist: *mut PropList,
indented: c_int,
) -> *mut c_char {
use std::io::Write;
if plist.is_null() {
return ptr::null_mut();
}
let plist = unsafe { &*plist };
let mut buf = Vec::new();
if indented != 0 {
if let Err(_) = write!(&mut buf, "{}", plist.display_indented()) {
return ptr::null_mut();
}
} else {
if let Err(_) = write!(&mut buf, "{}", plist.display_unindented()) {
return ptr::null_mut();
}
}
match CString::new(buf) {
Ok(s) => s.into_raw(),
Err(_) => ptr::null_mut(),
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMReadPropListFromFile(path: *const c_char) -> *mut PropList {
if path.is_null() {
return ptr::null_mut();
}
let path = unsafe { CStr::from_ptr(path) };
let Ok(path) = path.to_str() else {
return ptr::null_mut();
};
match PropList::from_file(path) {
Ok(plist) => Box::leak(Box::new(plist)),
Err(_) => {
// TODO: print error message.
ptr::null_mut()
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMReadPropListFromPipe(command: *const c_char) -> *mut PropList {
if command.is_null() {
return ptr::null_mut();
}
let command = unsafe { CStr::from_ptr(command) };
let Ok(command) = command.to_str() else {
return ptr::null_mut();
};
let command = OsString::from_str(command).unwrap();
let Ok(output) = std::process::Command::new("/bin/sh")
.arg("-c")
.arg(command)
.output()
else {
// TODO: print error message.
return ptr::null_mut();
};
let Ok(output) = String::from_utf8(output.stdout) else {
// TODO: print error message.
return ptr::null_mut();
};
match parser::from_str(&output) {
Ok(plist) => Box::leak(Box::new(plist)),
Err(_) => {
// TODO: print error message.
ptr::null_mut()
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn WMWritePropListToFile(
plist: *mut PropList,
path: *const c_char,
) -> c_int {
if plist.is_null() || path.is_null() {
return 0;
}
let plist = unsafe {
&*plist
};
let path = unsafe {
CStr::from_ptr(path)
};
let Some(path) = path_from_cstr(path) else {
// TODO: complain.
return 0;
};
match plist.write_to_file(&path) {
Ok(_) => return 1,
Err(_) => {
// TODO: complain.
return 0;
}
}
}
}
wutil-rs/src/prop_list/parser.rs
+1463
View File
File diff suppressed because it is too large Load Diff
wutil-rs/src/prop_list/writer.rs
+722
View File
@@ -0,0 +1,722 @@
//! Rendering of [`super::PropList`]s to text.
//!
//! To use this module, call [`super::PropList::display_indented`] or
//! [`super::PropList::display_unindented`].
//!
//! ## Rust rewrite notes
//!
//! This should work well enough for writing Window Maker state to disk, but it
//! is not a perfect reimplementation of the behavior of classic WUtils PropList
//! serialization. In particular, the WUtils hashtable has a different key
//! iteration order than Rust's `HashMap`, so this library may write dictionary
//! entries to disk in a different order.
use super::{parser, Node};
use std::{
fmt::{self, Write},
ops::Deref,
};
/// Maximum width for a chunk of text being rendered with `Inline::Soft` before
/// falling back to `Inline::No`.
const SOFT_LINEBREAK_WIDTH: usize = 77;
/// Describes the line-breaking strategy for rendering a `Node`.
#[derive(Clone, Copy, Eq, PartialEq)]
pub(crate) enum Inline {
/// Do not attempt to render with no linebreaks.
No,
/// Attempt to render with no linebreaks, but fall back to `Inline::No` if
/// the result is too wide.
Soft,
/// Render with no linebreaks, regardless of output width.
Hard,
}
/// Bundles a reference to a `Node` with rendering instructions.
pub(crate) struct Display<N: Deref<Target = Node>> {
/// Line-breaking strategy.
pub(crate) inline: Inline,
/// Whether to render `node` as if it is the first item on a new line.
pub(crate) clear_left: bool,
/// Indentation level to render `node` at.
pub(crate) indentation: u32,
/// Amount by which `indentation` should increase when rendering children of
/// `node`.
pub(crate) increment: u32,
/// The `Node` to render.
pub(crate) node: N,
}
/// Quick and dirty single-branch lookup mapping `b` to a hex character. Only
/// valid for `b` in `[0, 15]`.
fn byte_char(b: u8) -> char {
match b {
0 => '0',
1 => '1',
2 => '2',
3 => '3',
4 => '4',
5 => '5',
6 => '6',
7 => '7',
8 => '8',
9 => '9',
10 => 'a',
11 => 'b',
12 => 'c',
13 => 'd',
14 => 'e',
15 => 'f',
_ => unreachable!(),
}
}
impl<N: Deref<Target = Node>> Display<N> {
/// Writes whitespace to `f` for the current level of indentation.
fn write_indent(&self, f: &mut fmt::Formatter) -> fmt::Result {
for _ in 0..self.indentation {
f.write_char(' ')?;
}
Ok(())
}
}
/// Writes a hexadecimal representation of `bytes` to `f`, splitting `bytes` up
/// into space-delimited 32-bit quartets for readability.
fn write_data_bytes(bytes: &[u8], f: &mut fmt::Formatter) -> fmt::Result {
fn write(b: u8, f: &mut fmt::Formatter) -> fmt::Result {
let upper = (b >> 3) as u8;
let lower = (b & 0x0F) as u8;
write!(f, "{}", byte_char(upper))?;
write!(f, "{}", byte_char(lower))
}
let mut chunks = bytes.chunks(4);
if let Some(first) = chunks.next() {
for b in first {
write(*b, f)?;
}
}
for seg in chunks {
f.write_char(' ')?;
for b in seg {
write(*b, f)?;
}
}
Ok(())
}
/// Writes `s` to `f`, backslash-escaping special characters as appropriate for
/// a quoted property list string.
fn write_escaped_string(s: &str, f: &mut fmt::Formatter) -> fmt::Result {
for c in s.chars() {
match c {
'\x07' => f.write_str(r#"\a"#)?,
'\x08' => f.write_str(r#"\b"#)?,
'\t' => f.write_str(r#"\t"#)?,
'\n' => f.write_str(r#"\n"#)?,
'\x0B' => f.write_str(r#"\v"#)?,
'\x0D' => f.write_str(r#"\f"#)?,
'\\' => f.write_str(r#"\\"#)?,
'"' => f.write_str(r#"\\""#)?,
c => f.write_char(c)?,
}
}
Ok(())
}
impl<N: Deref<Target = Node>> fmt::Display for Display<N> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.clear_left {
writeln!(f, "")?;
self.write_indent(f)?;
}
match &*self.node {
Node::Array(items) if self.inline != Inline::No => {
// Try to fit everything in one line.
let mut buf = String::new();
buf.push('(');
let mut items = items.iter();
if let Some(first) = items.next() {
write!(
&mut buf,
"{}",
Display {
inline: self.inline,
clear_left: false,
indentation: self.indentation,
increment: self.increment,
node: first.0.borrow(),
}
)?;
}
for next in items {
write!(
&mut buf,
", {}",
Display {
inline: self.inline,
clear_left: false,
indentation: self.indentation,
increment: self.increment,
node: next.0.borrow(),
}
)?;
}
buf.push(')');
if self.inline == Inline::Soft && buf.chars().count() > SOFT_LINEBREAK_WIDTH {
write!(
f,
"{}",
Display {
inline: Inline::No,
clear_left: false,
indentation: self.indentation,
increment: self.increment,
node: &*self.node,
}
)?;
} else {
f.write_str(&buf)?;
}
}
Node::Array(items) if items.is_empty() => f.write_str("()")?,
Node::Array(items) => {
f.write_char('(')?;
let mut items = items.iter();
if let Some(first) = items.next() {
write!(
f,
"{}",
Display {
inline: Inline::Soft,
clear_left: true,
indentation: self.indentation + self.increment,
increment: self.increment,
node: first.0.borrow(),
}
)?;
}
for next in items {
f.write_char(',')?;
write!(
f,
"{}",
Display {
inline: Inline::Soft,
clear_left: true,
indentation: self.indentation + self.increment,
increment: self.increment,
node: next.0.borrow(),
}
)?;
}
writeln!(f, "")?;
self.write_indent(f)?;
f.write_char(')')?;
}
Node::Data(bytes) => {
write!(f, "<")?;
write_data_bytes(bytes, f)?;
write!(f, ">")?;
}
Node::Dictionary(items) if items.is_empty() => write!(f, "{{}}")?,
Node::Dictionary(items) if self.inline != Inline::No => {
// Try to fit everything in one line.
let mut buf = String::new();
buf.push('{');
for (k, v) in items {
write!(
&mut buf,
" {} = {};",
Display {
inline: self.inline,
clear_left: false,
indentation: self.indentation,
increment: self.increment,
node: k.0.borrow(),
},
Display {
inline: self.inline,
clear_left: false,
indentation: self.indentation,
increment: self.increment,
node: v.0.borrow(),
}
)?;
}
write!(&mut buf, " }}")?;
if self.inline == Inline::Soft && buf.chars().count() > SOFT_LINEBREAK_WIDTH {
write!(
f,
"{}",
Display {
inline: Inline::No,
clear_left: false,
indentation: self.indentation,
increment: self.increment,
node: &*self.node,
}
)?;
} else {
f.write_str(&buf)?;
}
}
Node::Dictionary(items) => {
write!(f, "{{")?;
for (k, v) in items {
write!(
f,
"{} = {};",
Display {
inline: Inline::Soft,
clear_left: true,
indentation: self.indentation + self.increment,
increment: self.increment,
node: k.0.borrow(),
},
Display {
inline: Inline::Soft,
clear_left: false,
indentation: self.indentation + self.increment,
increment: self.increment,
node: v.0.borrow(),
}
)?;
}
writeln!(f, "")?;
self.write_indent(f)?;
f.write_char('}')?;
}
Node::String(s) => {
let mut unquoted = !s.is_empty();
for c in s.as_bytes() {
if !parser::is_unquoted_char(*c as char) {
unquoted = false;
break;
}
}
if unquoted {
write!(f, "{}", s.to_string_lossy())?;
} else {
f.write_char('"')?;
write_escaped_string(&s.to_string_lossy(), f)?;
f.write_char('"')?;
}
}
}
Ok(())
}
}
#[cfg(test)]
mod test {
use crate::prop_list::{Node, PropList};
use std::ffi::CString;
fn pl_array(xs: Vec<PropList>) -> PropList {
PropList::new(Node::Array(xs))
}
fn pl_string(s: &str) -> PropList {
PropList::new(Node::String(CString::new(s.as_bytes()).unwrap()))
}
#[test]
fn write_empty_string() {
let serialized = format!("{:?}", pl_string(""));
assert_eq!(serialized, r#""""#);
}
#[test]
fn write_unquoted_string() {
let serialized = format!("{:?}", pl_string("hello"));
assert_eq!(serialized, r#"hello"#);
}
#[test]
fn write_quoted_string() {
let serialized = format!("{:?}", pl_string("hello, world!"));
assert_eq!(serialized, r#""hello, world!""#);
}
#[test]
fn write_flat_array() {
let serialized = format!(
"{:?}",
pl_array(vec![pl_string("hello"), pl_string("world")])
);
assert_eq!(serialized, r#"(hello, world)"#);
}
#[test]
fn write_empty_array() {
let serialized = format!("{:?}", pl_array(vec![]));
assert_eq!(serialized, r#"()"#);
}
#[test]
fn write_nested_array() {
let serialized = format!(
"{:?}",
pl_array(vec![
pl_array(vec![pl_string("hello"), pl_string("world")]),
pl_string("baz"),
pl_string("quux plugh")
])
);
assert_eq!(serialized, r#"((hello, world), baz, "quux plugh")"#);
}
#[test]
fn write_long_nested_array() {
let serialized = format!(
"{:?}",
pl_array(vec![
pl_array(vec![pl_string("hello"), pl_string("world")]),
pl_string("baz"),
pl_string("quux plugh"),
pl_string("etc"),
pl_array(vec![
pl_string("lots"),
pl_string("of"),
pl_string("words"),
pl_string("go"),
pl_array(vec![
pl_string("here"),
pl_string("and"),
pl_string("stuff"),
pl_string("blah"),
pl_string("blah"),
pl_string("blah"),
])
])
])
);
assert_eq!(
serialized,
r#"(
(hello, world),
baz,
"quux plugh",
etc,
(lots, of, words, go, (here, and, stuff, blah, blah, blah))
)"#
);
}
#[test]
fn roundtrip_wm_state() {
let original = r#"{
Dock = {
AutoRaiseLower = No;
Applications = (
{
Forced = No;
Name = Logo.WMDock;
BuggyApplication = No;
AutoLaunch = No;
Position = "0,0";
Lock = Yes;
Command = "/usr/bin/WPrefs";
},
{
Forced = No;
Name = wmweather.wmweather;
DropCommand = "wmweather -s KBOS %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,4";
Lock = Yes;
PasteCommand = "wmweather -s KBOS %s";
Command = "wmweather -s KBOS";
},
{
Forced = No;
Name = wmclock.WMClock;
DropCommand = "wmclock %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,3";
Lock = Yes;
PasteCommand = "wmclock %s";
Command = wmclock;
},
{
Forced = No;
Name = emacs.Emacs;
DropCommand = "emacsclient -c %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,2";
Lock = Yes;
PasteCommand = "emacsclient -c %s";
Command = "emacsclient -";
},
{
Forced = No;
Name = wmfire.wmfire;
DropCommand = "wmfire -m %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,5";
Lock = Yes;
PasteCommand = "wmfire -m %s";
Command = "wmfire -m";
},
{
Forced = No;
Name = wmnet.WMNET;
DropCommand = "wmnet -W enp0s31f6 %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,7";
Lock = Yes;
PasteCommand = "wmnet -W enp0s31f6 %s";
Command = "wmnet -W enp0s31f6";
},
{
Forced = No;
Name = wmtemp.DockApp;
DropCommand = "wmtemp -f %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,6";
Lock = Yes;
PasteCommand = "wmtemp -f %s";
Command = "wmtemp -f";
},
{
Forced = No;
Name = firefox.Firefox;
DropCommand = "firefox %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,1";
Lock = Yes;
PasteCommand = "firefox %s";
Command = firefox;
},
{
Forced = No;
Name = "org\\.gnome\\.Weather.org\\.gnome\\.Weather";
DropCommand = "org.gnome.Weather %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,8";
Lock = Yes;
PasteCommand = "org.gnome.Weather %s";
Command = "/usr/bin/gnome-weather";
},
{
Forced = No;
Name = Zotero.Zotero;
DropCommand = "/home/stu/bin/zotero %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,9";
Lock = Yes;
PasteCommand = "/home/stu/bin/zotero %s";
Command = "/home/stu/bin/zotero";
}
);
Lowered = Yes;
Position = "2496,0";
Applications1440 = (
{
Forced = No;
Name = Logo.WMDock;
BuggyApplication = No;
AutoLaunch = No;
Position = "0,0";
Lock = Yes;
Command = "/usr/bin/WPrefs";
},
{
Forced = No;
Name = wmweather.wmweather;
DropCommand = "wmweather -s KBOS %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,4";
Lock = Yes;
PasteCommand = "wmweather -s KBOS %s";
Command = "wmweather -s KBOS";
},
{
Forced = No;
Name = wmclock.WMClock;
DropCommand = "wmclock %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,3";
Lock = Yes;
PasteCommand = "wmclock %s";
Command = wmclock;
},
{
Forced = No;
Name = emacs.Emacs;
DropCommand = "emacsclient -c %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,2";
Lock = Yes;
PasteCommand = "emacsclient -c %s";
Command = "emacsclient -";
},
{
Forced = No;
Name = wmfire.wmfire;
DropCommand = "wmfire -m %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,5";
Lock = Yes;
PasteCommand = "wmfire -m %s";
Command = "wmfire -m";
},
{
Forced = No;
Name = wmnet.WMNET;
DropCommand = "wmnet -W enp0s31f6 %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,7";
Lock = Yes;
PasteCommand = "wmnet -W enp0s31f6 %s";
Command = "wmnet -W enp0s31f6";
},
{
Forced = No;
Name = wmtemp.DockApp;
DropCommand = "wmtemp -f %d";
BuggyApplication = No;
AutoLaunch = Yes;
Position = "0,6";
Lock = Yes;
PasteCommand = "wmtemp -f %s";
Command = "wmtemp -f";
},
{
Forced = No;
Name = firefox.Firefox;
DropCommand = "firefox %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,1";
Lock = Yes;
PasteCommand = "firefox %s";
Command = firefox;
},
{
Forced = No;
Name = "org\\.gnome\\.Weather.org\\.gnome\\.Weather";
DropCommand = "org.gnome.Weather %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,8";
Lock = Yes;
PasteCommand = "org.gnome.Weather %s";
Command = "/usr/bin/gnome-weather";
},
{
Forced = No;
Name = Zotero.Zotero;
DropCommand = "/home/stu/bin/zotero %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "0,9";
Lock = Yes;
PasteCommand = "/home/stu/bin/zotero %s";
Command = "/home/stu/bin/zotero";
}
);
};
Clip = {
Forced = No;
Name = Logo.WMClip;
DropCommand = "wmsetbg -u -t %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "2496,1376";
Lock = No;
Command = "-";
};
Drawers = ();
Workspaces = (
{
Clip = {
AutoRaiseLower = No;
AutoCollapse = No;
Applications = (
{
Forced = No;
Name = xsnow.Xsnow;
DropCommand = "xsnow %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "-2,0";
Lock = No;
PasteCommand = "xsnow %s";
Command = xsnow;
Omnipresent = No;
},
{
Forced = No;
Name = "thunderbird.Thunderbird-default";
DropCommand = "thunderbird %d";
BuggyApplication = No;
AutoLaunch = No;
Position = "-1,0";
Lock = No;
PasteCommand = "thunderbird %s";
Command = thunderbird;
Omnipresent = No;
}
);
Collapsed = No;
AutoAttractIcons = No;
Lowered = Yes;
};
Name = Mail;
},
{
Clip = {
AutoRaiseLower = No;
AutoCollapse = No;
Applications = ();
Collapsed = No;
AutoAttractIcons = No;
Lowered = Yes;
};
Name = Plans;
},
{
Clip = {
AutoRaiseLower = No;
AutoCollapse = No;
Applications = ();
Collapsed = No;
AutoAttractIcons = No;
Lowered = Yes;
};
Name = Misc;
},
);
}"#;
// We do (original serialized) -> plist -> (serialized) -> plist and
// compare the two plists because Rust's hashtable ordering (which is
// reflected in the serialized output) does not match the original
// WUtils hashtable ordering.
let original_plist = super::parser::from_str(original).unwrap();
let serialized = format!("{}", original_plist.display_indented());
let deserialized = super::parser::from_str(&serialized).unwrap();
assert_eq!(original_plist, deserialized);
}
}