From e1ec354306742a5804a20e2651cf49945cd17287 Mon Sep 17 00:00:00 2001 From: Matias Linares Date: Sat, 28 Nov 2015 22:16:43 -0300 Subject: Better socket handling The socket interface now allows almost everything that vould be done by the internals of the window manager. Also the Window manager now closes fine (on a success exit). --- src/socket/parser.rs | 215 ++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 163 insertions(+), 52 deletions(-) (limited to 'src/socket/parser.rs') diff --git a/src/socket/parser.rs b/src/socket/parser.rs index e8dd9ec..0de0248 100644 --- a/src/socket/parser.rs +++ b/src/socket/parser.rs @@ -9,94 +9,205 @@ use x11::xlib; use x11::keysym; use command::*; -use dotwm::DotWM; +use ::socket::ParsedCmd; +use ::socket::FnType; -use nom::{IResult,alpha,multispace}; -use nom::IResult::*; -use std::str; - -named!(token<&str>, - map_res!( - alpha, str::from_utf8)); +macro_rules! simple_try { + ($expr:expr) => (match $expr { + Ok(val) => val, + Err(err) => { + return Err(err) + } + }) +} -fn slice2str(input: Vec<&[u8]>) -> Vec<&str> { - let res: Vec<&str> = input.iter() - .map(|x| str::from_utf8(x).unwrap()) - .collect(); - res +fn modifier_from<'a>(s: &'a str) -> Result { + match s { + "Mod1" => Ok(xlib::Mod4Mask), + "Mod2" => Ok(xlib::Mod4Mask), + "Mod3" => Ok(xlib::Mod4Mask), + "Mod4" => Ok(xlib::Mod4Mask), + "Control" => Ok(xlib::ControlMask), + "Shift" => Ok(xlib::ShiftMask), + _ => Err("unknown modifier"), + } } -named!(args >, - map!( - separated_list!( - multispace, alpha), - slice2str)); +fn modifiers<'a>(s: &'a str) -> Result, &'static str> { + let mut result = vec![]; -fn modifier<'a>(s: &'a str) -> Result { - match s { - "Mod1Mask" => Ok(xlib::Mod4Mask), - "Mod2Mask" => Ok(xlib::Mod4Mask), - "Mod3Mask" => Ok(xlib::Mod4Mask), - "Mod4Mask" => Ok(xlib::Mod4Mask), - "ControlMask" => Ok(xlib::ControlMask), - "ShiftMask" => Ok(xlib::ShiftMask), - _ => Err(()), + for smod in s.split("-") { + let modifier = simple_try!(modifier_from(smod)); + result.push(modifier); } + + Ok(result) } -fn str_to_key<'a>(s: &'a str) -> Result { +fn key<'a>(s: &'a str) -> Result { match s { + "a" => Ok(keysym::XK_a), + "b" => Ok(keysym::XK_b), + "c" => Ok(keysym::XK_c), + "d" => Ok(keysym::XK_d), + "e" => Ok(keysym::XK_e), + "f" => Ok(keysym::XK_f), + "g" => Ok(keysym::XK_g), "h" => Ok(keysym::XK_h), + "i" => Ok(keysym::XK_i), "j" => Ok(keysym::XK_j), "k" => Ok(keysym::XK_k), "l" => Ok(keysym::XK_l), - "Tab" => Ok(keysym::XK_Tab), + "m" => Ok(keysym::XK_m), + "n" => Ok(keysym::XK_n), + "o" => Ok(keysym::XK_o), "p" => Ok(keysym::XK_p), - "Return" => Ok(keysym::XK_Return), "q" => Ok(keysym::XK_q), - _ => Err(()), + "r" => Ok(keysym::XK_r), + "s" => Ok(keysym::XK_s), + "t" => Ok(keysym::XK_t), + "u" => Ok(keysym::XK_u), + "v" => Ok(keysym::XK_v), + "w" => Ok(keysym::XK_w), + "x" => Ok(keysym::XK_x), + "y" => Ok(keysym::XK_y), + "z" => Ok(keysym::XK_z), + "A" => Ok(keysym::XK_A), + "B" => Ok(keysym::XK_B), + "C" => Ok(keysym::XK_C), + "D" => Ok(keysym::XK_D), + "E" => Ok(keysym::XK_E), + "F" => Ok(keysym::XK_F), + "G" => Ok(keysym::XK_G), + "H" => Ok(keysym::XK_H), + "I" => Ok(keysym::XK_I), + "J" => Ok(keysym::XK_J), + "K" => Ok(keysym::XK_K), + "L" => Ok(keysym::XK_L), + "M" => Ok(keysym::XK_M), + "N" => Ok(keysym::XK_N), + "O" => Ok(keysym::XK_O), + "P" => Ok(keysym::XK_P), + "Q" => Ok(keysym::XK_Q), + "R" => Ok(keysym::XK_R), + "S" => Ok(keysym::XK_S), + "T" => Ok(keysym::XK_T), + "U" => Ok(keysym::XK_U), + "V" => Ok(keysym::XK_V), + "W" => Ok(keysym::XK_W), + "X" => Ok(keysym::XK_X), + "Y" => Ok(keysym::XK_Y), + "Z" => Ok(keysym::XK_Z), + "Tab" => Ok(keysym::XK_Tab), + "Return" => Ok(keysym::XK_Return), + _ => Err("unknown key"), } } -fn str_to_func<'a>(s: &'a str) -> Result { +fn func<'a>(s: &'a str) -> Result { match s { "exec" => Ok(exec), - "move_win" => Ok(move_win), - "resize_win" => Ok(resize_win), - _ => Err(()), + "move-win" => Ok(move_win), + "move-win-to" => Ok(move_win_to), + "resize-win" => Ok(resize_win), + "focus-next" => Ok(focus_next), + "quit" => Ok(quit_dotwm), + _ => Err("unknown function"), } } -pub fn parse<'a>(dotwm: &mut DotWM, bindings: &mut BindingHash, input: &'a str) -> &'a str { - let args: Vec<&str> = input.split_whitespace().collect(); +pub fn parse<'a>(input: &'a str) -> Result, &'static str> { + let args: Vec<&'a str> = input.split_whitespace().collect(); match args.first() { Some(cmd) => { match cmd { - &"add-binding" => { - let modifier = modifier(args[1]).unwrap(); - let key = str_to_key(args[2]).unwrap(); - let func = str_to_func(args[3]).unwrap(); - let arguments = &args[4..]; + &"bind" => { + if args.len() > 2 { + let modifiers = simple_try!(modifiers(args[1])); + let key = simple_try!(key(args[2])); + let func = simple_try!(func(args[3])); + let arguments: &[&'a str]= &args[4..]; - add_binding(dotwm, bindings, key, modifier, func, arguments); + Ok(ParsedCmd { + f: FnType::Bind, + modifiers: modifiers, + key: key, + args: arguments.to_vec(), + func: func, + }) + } else { + Err("missing arguments") + } + }, + &"exec" => { + Ok(ParsedCmd { + f: FnType::Exec, + modifiers: vec![], + key: 0, + args: vec![], + func: exec + }) + }, + _ => { + Err("unknown command") }, - &"exec" => { println!("exec"); }, - _ => { println!("anotherthing ._."); }, } }, - None => println!("error"), + None => Err("no input"), + } +} + +#[test] +fn parse_unknown() { + let res = parse("unknown"); + if let Err(e) = res { + assert_eq!(e, "unknown command"); + } else { + assert!(false); } - "ok" } #[test] -fn parse_test() { - assert_eq!(token(&b"exec"[..]), IResult::Done(&b""[..], "exec")); +fn parse_bind_modifier() { + let res = parse("bind modifier1 k exec "); + if let Err(e) = res { + assert_eq!(e, "unknown modifier"); + } else { + assert!(false); + } + + let res2 = parse("bind Mod4 k exec "); + if let Ok(modifier) = res2 { + assert_eq!(modifier.modifiers[0], xlib::Mod4Mask); + } else { + assert!(false); + } } #[test] -fn parse_args() { - assert_eq!(args(&b"hola chau"[..]), - IResult::Done(&b""[..], vec!["hola", "chau"])); +fn parse_bind_key() { + let res = parse("bind Mod4 ' exec "); + if let Err(e) = res { + assert_eq!(e, "unknown key"); + } else { + assert!(false); + } + + let res2 = parse("bind Mod4 k exec "); + if let Ok(modifier) = res2 { + assert_eq!(modifier.key, keysym::XK_k); + } else { + assert!(false); + } +} + +#[test] +fn parse_exec() { + let res = parse("exec Mod4 ' exec "); + if let Ok(pcmd) = res { + assert_eq!(pcmd.f, FnType::Exec); + } else { + assert!(false); + } } -- cgit v1.2.3-54-g00ecf