2016-05-25 03:55:51 +00:00
|
|
|
//! Alacritty - The GPU Enhanced Terminal
|
|
|
|
#![feature(question_mark)]
|
Initial ANSI parser implementation
This is the initial terminal stream parsing implementation for
Alacritty. There are currently several TODOs, FIXMEs, and unimplemented!
things scattered about still, but what's here is good enough to
correctly parse my zsh startup.
The `Parser` implementation is largely based on the suck-less _simple
terminal_ parser. Because this is Rust and Rust has a fantastic type
system, some improvements are possible. First, `Parser` is a struct, and
its data is stored internally instead of statically. Second, there's no
terminal updates hard-coded into the parser. Instead, `Parser` is
generic over a `Handler` type which has methods for all of the actions
supported by the parser. Because Parser is generic, it should be
possible (with proper inlining) to have equivalent performance to the
hard-coded version.
In addition to using _simple terminal_ as a reference, there's a doc in
Alacritty's repository `docs/ansicode.txt`, a summary of the ANSI
terminal protocol, which has been referenced extensively.
There's probably a large number escapes we don't handle, and that's ok.
There's a lot that aren't necessary for everyday terminal usage. If you
feel like something that's not supported should be, feel free to add it.
Please try not to become overzealous and adding support for sequences
only used by folks trapped in 1988.
2016-05-29 05:09:25 +00:00
|
|
|
#![feature(range_contains)]
|
|
|
|
#![feature(inclusive_range_syntax)]
|
|
|
|
#![feature(io)]
|
2016-05-31 03:44:37 +00:00
|
|
|
#![feature(unicode)]
|
2016-05-25 03:55:51 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
extern crate font;
|
2016-02-21 23:20:03 +00:00
|
|
|
extern crate libc;
|
2016-02-24 04:42:58 +00:00
|
|
|
extern crate glutin;
|
|
|
|
extern crate cgmath;
|
2016-06-04 17:54:33 +00:00
|
|
|
extern crate notify;
|
2016-06-10 03:39:40 +00:00
|
|
|
extern crate errno;
|
2016-06-28 02:46:24 +00:00
|
|
|
extern crate parking_lot;
|
2016-02-21 23:20:03 +00:00
|
|
|
|
2016-06-06 23:54:15 +00:00
|
|
|
#[macro_use]
|
|
|
|
extern crate bitflags;
|
|
|
|
|
Initial ANSI parser implementation
This is the initial terminal stream parsing implementation for
Alacritty. There are currently several TODOs, FIXMEs, and unimplemented!
things scattered about still, but what's here is good enough to
correctly parse my zsh startup.
The `Parser` implementation is largely based on the suck-less _simple
terminal_ parser. Because this is Rust and Rust has a fantastic type
system, some improvements are possible. First, `Parser` is a struct, and
its data is stored internally instead of statically. Second, there's no
terminal updates hard-coded into the parser. Instead, `Parser` is
generic over a `Handler` type which has methods for all of the actions
supported by the parser. Because Parser is generic, it should be
possible (with proper inlining) to have equivalent performance to the
hard-coded version.
In addition to using _simple terminal_ as a reference, there's a doc in
Alacritty's repository `docs/ansicode.txt`, a summary of the ANSI
terminal protocol, which has been referenced extensively.
There's probably a large number escapes we don't handle, and that's ok.
There's a lot that aren't necessary for everyday terminal usage. If you
feel like something that's not supported should be, feel free to add it.
Please try not to become overzealous and adding support for sequences
only used by folks trapped in 1988.
2016-05-29 05:09:25 +00:00
|
|
|
#[macro_use]
|
|
|
|
mod macros;
|
|
|
|
|
2016-02-26 04:59:21 +00:00
|
|
|
mod renderer;
|
2016-06-09 15:30:55 +00:00
|
|
|
pub mod grid;
|
2016-05-21 18:08:50 +00:00
|
|
|
mod meter;
|
2016-06-23 16:48:31 +00:00
|
|
|
mod input;
|
2016-05-25 03:55:51 +00:00
|
|
|
mod tty;
|
2016-06-09 15:30:55 +00:00
|
|
|
pub mod ansi;
|
2016-05-31 03:44:37 +00:00
|
|
|
mod term;
|
2016-06-08 04:11:23 +00:00
|
|
|
mod util;
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-09 15:30:55 +00:00
|
|
|
use std::io::{Read, Write, BufWriter};
|
2016-06-28 02:46:24 +00:00
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
|
use std::sync::{mpsc, Arc};
|
|
|
|
|
|
|
|
use parking_lot::Mutex;
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-23 16:48:31 +00:00
|
|
|
use font::FontDesc;
|
2016-04-10 23:19:39 +00:00
|
|
|
use grid::Grid;
|
2016-05-31 03:44:37 +00:00
|
|
|
use meter::Meter;
|
2016-06-09 15:30:55 +00:00
|
|
|
use renderer::{QuadRenderer, GlyphCache};
|
2016-06-09 15:16:44 +00:00
|
|
|
use term::Term;
|
2016-06-09 04:24:31 +00:00
|
|
|
use tty::process_should_exit;
|
2016-06-09 15:16:44 +00:00
|
|
|
use util::thread;
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
/// Things that the render/update thread needs to respond to
|
|
|
|
#[derive(Debug)]
|
|
|
|
enum Event {
|
|
|
|
PtyChar(char),
|
|
|
|
Glutin(glutin::Event),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
|
|
enum ShouldExit {
|
|
|
|
Yes,
|
|
|
|
No
|
|
|
|
}
|
|
|
|
|
2016-06-23 16:48:31 +00:00
|
|
|
struct WriteNotifier<'a, W: Write + 'a>(&'a mut W);
|
|
|
|
impl<'a, W: Write> input::Notify for WriteNotifier<'a, W> {
|
|
|
|
fn notify(&mut self, message: &str) {
|
|
|
|
self.0.write(message.as_bytes()).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
fn handle_event<W>(event: Event,
|
|
|
|
writer: &mut W,
|
|
|
|
terminal: &mut Term,
|
2016-06-23 16:48:31 +00:00
|
|
|
pty_parser: &mut ansi::Parser,
|
|
|
|
input_processor: &mut input::Processor) -> ShouldExit
|
2016-06-09 15:06:47 +00:00
|
|
|
where W: Write
|
|
|
|
{
|
|
|
|
match event {
|
|
|
|
// Handle char from pty
|
|
|
|
Event::PtyChar(c) => pty_parser.advance(terminal, c),
|
|
|
|
// Handle keyboard/mouse input and other window events
|
|
|
|
Event::Glutin(gevent) => match gevent {
|
|
|
|
glutin::Event::Closed => return ShouldExit::Yes,
|
|
|
|
glutin::Event::ReceivedCharacter(c) => {
|
|
|
|
let encoded = c.encode_utf8();
|
|
|
|
writer.write(encoded.as_slice()).unwrap();
|
|
|
|
},
|
|
|
|
glutin::Event::KeyboardInput(state, _code, key) => {
|
2016-06-23 16:48:31 +00:00
|
|
|
input_processor.process(state, key, &mut WriteNotifier(writer), *terminal.mode())
|
2016-06-09 15:06:47 +00:00
|
|
|
},
|
|
|
|
_ => ()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ShouldExit::No
|
|
|
|
}
|
|
|
|
|
2016-05-31 03:44:37 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
|
|
|
|
pub struct Rgb {
|
|
|
|
r: u8,
|
|
|
|
g: u8,
|
|
|
|
b: u8,
|
|
|
|
}
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-05-21 04:36:28 +00:00
|
|
|
mod gl {
|
|
|
|
include!(concat!(env!("OUT_DIR"), "/gl_bindings.rs"));
|
|
|
|
}
|
|
|
|
|
2016-06-04 22:30:17 +00:00
|
|
|
#[derive(Debug)]
|
2016-06-09 15:30:55 +00:00
|
|
|
pub struct TermProps {
|
2016-06-04 22:30:17 +00:00
|
|
|
width: f32,
|
|
|
|
height: f32,
|
2016-06-03 03:27:07 +00:00
|
|
|
cell_width: f32,
|
|
|
|
cell_height: f32,
|
2016-05-21 18:08:50 +00:00
|
|
|
}
|
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
#[cfg(target_os = "linux")]
|
|
|
|
static FONT: &'static str = "DejaVu Sans Mono";
|
|
|
|
#[cfg(target_os = "linux")]
|
|
|
|
static FONT_STYLE: &'static str = "Book";
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
#[cfg(target_os = "macos")]
|
|
|
|
static FONT: &'static str = "Menlo";
|
|
|
|
#[cfg(target_os = "macos")]
|
|
|
|
static FONT_STYLE: &'static str = "Regular";
|
2016-02-24 04:42:58 +00:00
|
|
|
|
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
fn main() {
|
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
let window = glutin::WindowBuilder::new()
|
|
|
|
.with_vsync()
|
|
|
|
.with_title("Alacritty")
|
|
|
|
.build().unwrap();
|
2016-06-10 03:39:40 +00:00
|
|
|
// window.set_window_resize_callback(Some(resize_callback as fn(u32, u32)));
|
|
|
|
|
|
|
|
gl::load_with(|symbol| window.get_proc_address(symbol) as *const _);
|
|
|
|
let (width, height) = window.get_inner_size_pixels().unwrap();
|
2016-02-28 04:26:31 +00:00
|
|
|
let dpr = window.hidpi_factor();
|
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
println!("device_pixel_ratio: {}", dpr);
|
|
|
|
|
2016-05-21 04:36:28 +00:00
|
|
|
let font_size = 11.;
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
let sep_x = 2.0;
|
|
|
|
let sep_y = -7.0;
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
let desc = FontDesc::new(FONT, FONT_STYLE);
|
|
|
|
let mut rasterizer = font::Rasterizer::new(96., 96., dpr);
|
2016-02-26 04:59:21 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
let metrics = rasterizer.metrics(&desc, font_size);
|
|
|
|
let cell_width = (metrics.average_advance + sep_x) as u32;
|
|
|
|
let cell_height = (metrics.line_height + sep_y) as u32;
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
println!("Cell Size: ({} x {})", cell_width, cell_height);
|
|
|
|
|
|
|
|
let num_cols = grid::num_cells_axis(cell_width, width);
|
|
|
|
let num_rows = grid::num_cells_axis(cell_height, height);
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-05-31 03:44:37 +00:00
|
|
|
let tty = tty::new(num_rows as u8, num_cols as u8);
|
|
|
|
tty.resize(num_rows as usize, num_cols as usize, width as usize, height as usize);
|
2016-06-09 15:30:55 +00:00
|
|
|
let reader = tty.reader();
|
|
|
|
let writer = tty.writer();
|
2016-05-25 03:55:51 +00:00
|
|
|
|
2016-04-10 23:19:39 +00:00
|
|
|
println!("num_cols, num_rows = {}, {}", num_cols, num_rows);
|
|
|
|
|
2016-06-09 15:30:55 +00:00
|
|
|
let grid = Grid::new(num_rows as usize, num_cols as usize);
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-06-06 21:31:12 +00:00
|
|
|
let props = TermProps {
|
|
|
|
cell_width: cell_width as f32,
|
|
|
|
cell_height: cell_height as f32,
|
|
|
|
height: height as f32,
|
|
|
|
width: width as f32,
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut glyph_cache = GlyphCache::new(rasterizer, desc, font_size);
|
2016-06-28 02:46:24 +00:00
|
|
|
let needs_render = Arc::new(AtomicBool::new(true));
|
|
|
|
let needs_render2 = needs_render.clone();
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
let (tx, rx) = mpsc::channel();
|
|
|
|
let reader_tx = tx.clone();
|
2016-06-09 04:24:31 +00:00
|
|
|
let reader_thread = thread::spawn_named("TTY Reader", move || {
|
2016-05-31 03:44:37 +00:00
|
|
|
for c in reader.chars() {
|
|
|
|
let c = c.unwrap();
|
2016-06-09 15:06:47 +00:00
|
|
|
reader_tx.send(Event::PtyChar(c)).unwrap();
|
2016-05-31 03:44:37 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
let terminal = Arc::new(Mutex::new(Term::new(tty, grid)));
|
|
|
|
let term_ref = terminal.clone();
|
2016-05-31 03:44:37 +00:00
|
|
|
let mut meter = Meter::new();
|
|
|
|
|
|
|
|
let mut pty_parser = ansi::Parser::new();
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
let window = Arc::new(window);
|
|
|
|
let window_ref = window.clone();
|
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
let update_thread = thread::spawn_named("Update", move || {
|
|
|
|
'main_loop: loop {
|
|
|
|
let mut writer = BufWriter::new(&writer);
|
|
|
|
let mut input_processor = input::Processor::new();
|
2016-05-21 18:08:50 +00:00
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
// Handle case where renderer didn't acquire lock yet
|
|
|
|
if needs_render.load(Ordering::Acquire) {
|
|
|
|
::std::thread::yield_now();
|
|
|
|
continue;
|
|
|
|
}
|
2016-06-23 16:48:31 +00:00
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
if process_should_exit() {
|
|
|
|
break;
|
|
|
|
}
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
// Block waiting for next event and handle it
|
|
|
|
let event = match rx.recv() {
|
|
|
|
Ok(e) => e,
|
|
|
|
Err(mpsc::RecvError) => break,
|
|
|
|
};
|
|
|
|
|
|
|
|
// Need mutable terminal for updates; lock it.
|
|
|
|
let mut terminal = terminal.lock();
|
|
|
|
let res = handle_event(event,
|
|
|
|
&mut writer,
|
|
|
|
&mut *terminal,
|
|
|
|
&mut pty_parser,
|
|
|
|
&mut input_processor);
|
|
|
|
if res == ShouldExit::Yes {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle Any events that are in the queue
|
|
|
|
loop {
|
|
|
|
match rx.try_recv() {
|
2016-06-09 15:30:55 +00:00
|
|
|
Ok(e) => {
|
2016-06-23 16:48:31 +00:00
|
|
|
let res = handle_event(e,
|
|
|
|
&mut writer,
|
2016-06-28 02:46:24 +00:00
|
|
|
&mut *terminal,
|
2016-06-23 16:48:31 +00:00
|
|
|
&mut pty_parser,
|
|
|
|
&mut input_processor);
|
2016-06-28 02:46:24 +00:00
|
|
|
|
2016-06-09 15:30:55 +00:00
|
|
|
if res == ShouldExit::Yes {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
},
|
2016-06-28 02:46:24 +00:00
|
|
|
Err(mpsc::TryRecvError::Disconnected) => break 'main_loop,
|
|
|
|
Err(mpsc::TryRecvError::Empty) => break,
|
2016-06-09 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
// Release the lock if a render is needed
|
|
|
|
if needs_render.load(Ordering::Acquire) {
|
|
|
|
break;
|
2016-06-10 03:39:40 +00:00
|
|
|
}
|
2016-06-09 15:30:55 +00:00
|
|
|
}
|
2016-06-28 02:46:24 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
let render_thread = thread::spawn_named("Render", move || {
|
|
|
|
let _ = unsafe { window.make_current() };
|
|
|
|
unsafe {
|
|
|
|
gl::Viewport(0, 0, width as i32, height as i32);
|
|
|
|
gl::Enable(gl::BLEND);
|
|
|
|
gl::BlendFunc(gl::SRC1_COLOR, gl::ONE_MINUS_SRC1_COLOR);
|
|
|
|
gl::Enable(gl::MULTISAMPLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut renderer = QuadRenderer::new(width, height);
|
|
|
|
renderer.with_api(&props, |mut api| {
|
|
|
|
glyph_cache.init(&mut api);
|
|
|
|
});
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
loop {
|
2016-06-10 03:39:40 +00:00
|
|
|
unsafe {
|
|
|
|
gl::ClearColor(0.0, 0.0, 0.00, 1.0);
|
|
|
|
gl::Clear(gl::COLOR_BUFFER_BIT);
|
|
|
|
}
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
{
|
2016-06-28 02:46:24 +00:00
|
|
|
// Flag that it's time for render
|
|
|
|
needs_render2.store(true, Ordering::Release);
|
|
|
|
// Acquire term lock
|
|
|
|
let mut terminal = term_ref.lock();
|
|
|
|
// Have the lock, ok to lower flag
|
|
|
|
needs_render2.store(false, Ordering::Relaxed);
|
2016-06-10 03:39:40 +00:00
|
|
|
let _sampler = meter.sampler();
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
renderer.with_api(&props, |mut api| {
|
|
|
|
// Draw the grid
|
|
|
|
api.render_grid(terminal.grid(), &mut glyph_cache);
|
2016-05-21 18:08:50 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
// Also draw the cursor
|
2016-06-23 16:42:00 +00:00
|
|
|
if terminal.mode().contains(term::mode::SHOW_CURSOR) {
|
2016-06-10 03:39:40 +00:00
|
|
|
api.render_cursor(terminal.cursor(), &mut glyph_cache);
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
2016-06-09 04:24:31 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
// Draw render timer
|
|
|
|
let timing = format!("{:.3} usec", meter.average());
|
|
|
|
let color = Rgb { r: 0xd5, g: 0x4e, b: 0x53 };
|
|
|
|
renderer.with_api(&props, |mut api| {
|
|
|
|
api.render_string(&timing[..], &mut glyph_cache, &color);
|
|
|
|
});
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
window.swap_buffers().unwrap();
|
|
|
|
|
|
|
|
if process_should_exit() {
|
2016-06-28 02:46:24 +00:00
|
|
|
break;
|
2016-06-10 03:39:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
'event_processing: loop {
|
|
|
|
for event in window_ref.wait_events() {
|
|
|
|
tx.send(Event::Glutin(event)).unwrap();
|
|
|
|
if process_should_exit() {
|
|
|
|
break 'event_processing;
|
|
|
|
}
|
2016-06-09 04:24:31 +00:00
|
|
|
}
|
2016-02-24 04:42:58 +00:00
|
|
|
}
|
2016-06-08 04:12:21 +00:00
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
reader_thread.join().ok();
|
2016-06-10 03:39:40 +00:00
|
|
|
render_thread.join().ok();
|
2016-06-28 02:46:24 +00:00
|
|
|
update_thread.join().ok();
|
2016-06-09 04:24:31 +00:00
|
|
|
println!("Goodbye");
|
2016-02-24 04:42:58 +00:00
|
|
|
}
|
|
|
|
|