Applied-Software/ghostty
5
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2025-07-14 15:56:13 +03:00
Code Issues Packages Projects Releases Wiki Activity

remove tracy usage from all files

Browse Source
This commit is contained in:
Mitchell Hashimoto
2024-01-13 15:06:08 -08:00
parent 29717269ca
commit adb7958f61
14 changed files with 42 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/Surface.zig
View File

@ -30,7 +30,6 @@ const imgui = @import("imgui");
const Pty = @import("pty.zig").Pty;
const font = @import("font/main.zig");
const Command = @import("Command.zig");
const trace = @import("tracy").trace;
const terminal = @import("terminal/main.zig");
const configpkg = @import("config.zig");
const input = @import("input.zig");
@ -1048,9 +1047,6 @@ fn queueRender(self: *Surface) !void {
}
pub fn sizeCallback(self: *Surface, size: apprt.SurfaceSize) !void {
const tracy = trace(@src());
defer tracy.end();
const new_screen_size: renderer.ScreenSize = .{
.width = size.width,
.height = size.height,
@ -1453,9 +1449,6 @@ pub fn scrollCallback(
yoff: f64,
scroll_mods: input.ScrollMods,
) !void {
const tracy = trace(@src());
defer tracy.end();
// log.info("SCROLL: xoff={} yoff={} mods={}", .{ xoff, yoff, scroll_mods });
// Always show the mouse again if it is hidden
@ -1919,9 +1912,6 @@ pub fn mouseButtonCallback(
) !void {
// log.debug("mouse action={} button={} mods={}", .{ action, button, mods });
const tracy = trace(@src());
defer tracy.end();
// If we have an inspector, we always queue a render
if (self.inspector) |insp| {
defer self.queueRender() catch {};
@ -2275,9 +2265,6 @@ pub fn cursorPosCallback(
self: *Surface,
pos: apprt.CursorPos,
) !void {
const tracy = trace(@src());
defer tracy.end();
// Always show the mouse again if it is hidden
if (self.mouse.hidden) self.showMouse();

24
src/apprt/glfw.zig
View File

@ -8,7 +8,6 @@ const builtin = @import("builtin");
const build_config = @import("../build_config.zig");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const trace = @import("tracy").trace;
const glfw = @import("glfw");
const macos = @import("macos");
const objc = @import("objc");
@ -741,9 +740,6 @@ pub const Surface = struct {
}
fn charCallback(window: glfw.Window, codepoint: u21) void {
const tracy = trace(@src());
defer tracy.end();
const core_win = window.getUserPointer(CoreSurface) orelse return;
// We need a key event in order to process the charcallback. If it
@ -780,8 +776,6 @@ pub const Surface = struct {
glfw_action: glfw.Action,
glfw_mods: glfw.Mods,
) void {
const tracy = trace(@src());
defer tracy.end();
_ = scancode;
const core_win = window.getUserPointer(CoreSurface) orelse return;
@ -954,9 +948,6 @@ pub const Surface = struct {
}
fn focusCallback(window: glfw.Window, focused: bool) void {
const tracy = trace(@src());
defer tracy.end();
const core_win = window.getUserPointer(CoreSurface) orelse return;
core_win.focusCallback(focused) catch |err| {
log.err("error in focus callback err={}", .{err});
@ -965,9 +956,6 @@ pub const Surface = struct {
}
fn refreshCallback(window: glfw.Window) void {
const tracy = trace(@src());
defer tracy.end();
const core_win = window.getUserPointer(CoreSurface) orelse return;
core_win.refreshCallback() catch |err| {
log.err("error in refresh callback err={}", .{err});
@ -976,9 +964,6 @@ pub const Surface = struct {
}
fn scrollCallback(window: glfw.Window, xoff: f64, yoff: f64) void {
const tracy = trace(@src());
defer tracy.end();
// Glfw doesn't support any of the scroll mods.
const scroll_mods: input.ScrollMods = .{};
@ -994,9 +979,6 @@ pub const Surface = struct {
unscaled_xpos: f64,
unscaled_ypos: f64,
) void {
const tracy = trace(@src());
defer tracy.end();
const core_win = window.getUserPointer(CoreSurface) orelse return;
// Convert our unscaled x/y to scaled.
@ -1026,9 +1008,6 @@ pub const Surface = struct {
glfw_action: glfw.Action,
glfw_mods: glfw.Mods,
) void {
const tracy = trace(@src());
defer tracy.end();
const core_win = window.getUserPointer(CoreSurface) orelse return;
// Convert glfw button to input button
@ -1061,9 +1040,6 @@ pub const Surface = struct {
}
fn dropCallback(window: glfw.Window, paths: [][*:0]const u8) void {
const tracy = trace(@src());
defer tracy.end();
const surface = window.getUserPointer(CoreSurface) orelse return;
var list = std.ArrayList(u8).init(surface.alloc);

53
src/build_config.zig
View File

@ -10,6 +10,37 @@ const apprt = @import("apprt.zig");
const font = @import("font/main.zig");
const rendererpkg = @import("renderer.zig");
/// The build configuratin options. This may not be all available options
/// to `zig build` but it contains all the options that the Ghostty source
/// needs to know about at comptime.
///
/// We put this all in a single struct so that we can check compatibility
/// between options, make it easy to copy and mutate options for different
/// build types, etc.
pub const BuildConfig = struct {
app_runtime: apprt.Runtime = .none,
renderer: rendererpkg.Impl = .opengl,
font_backend: font.Backend = .freetype,
/// Configure the build options with our values.
pub fn addOptions(self: BuildConfig, step: *std.Build.Step.Options) void {
// We need to break these down individual because addOption doesn't
// support all types.
step.addOption(apprt.Runtime, "app_runtime", self.app_runtime);
step.addOption(font.Backend, "font_backend", self.font_backend);
step.addOption(rendererpkg.Impl, "renderer", self.renderer_impl);
}
/// Rehydrate our BuildConfig from the comptime options.
pub fn fromOptions() BuildConfig {
return .{
.app_runtime = std.meta.stringToEnum(apprt.Runtime, @tagName(options.app_runtime)).?,
.font_backend = std.meta.stringToEnum(font.Backend, @tagName(options.font_backend)).?,
.renderer = std.meta.stringToEnum(rendererpkg.Impl, @tagName(options.renderer)).?,
};
}
};
/// The semantic version of this build.
pub const version = options.app_version;
pub const version_string = options.app_version_string;
@ -18,23 +49,11 @@ pub const version_string = options.app_version_string;
/// building a standalone exe, an embedded lib, etc.
pub const artifact = Artifact.detect();
/// The runtime to back exe artifacts with.
pub const app_runtime: apprt.Runtime = switch (artifact) {
.lib => .none,
else => std.meta.stringToEnum(apprt.Runtime, @tagName(options.app_runtime)).?,
};
/// The font backend desired for the build.
pub const font_backend: font.Backend = std.meta.stringToEnum(
font.Backend,
@tagName(options.font_backend),
).?;
/// The renderer implementation to use.
pub const renderer: rendererpkg.Impl = std.meta.stringToEnum(
rendererpkg.Impl,
@tagName(options.renderer),
).?;
/// Our build configuration.
pub const config = BuildConfig.fromOptions();
pub const app_runtime: apprt.Runtime = config.app_runtime;
pub const font_backend: font.Backend = config.font_backend;
pub const renderer: rendererpkg.Impl = config.renderer;
/// We want to integrate with Flatpak APIs.
pub const flatpak = options.flatpak;

4
src/font/shaper/harfbuzz.zig
View File

@ -2,7 +2,6 @@ const std = @import("std");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const harfbuzz = @import("harfbuzz");
const trace = @import("tracy").trace;
const font = @import("../main.zig");
const Face = font.Face;
const DeferredFace = font.DeferredFace;
@ -106,9 +105,6 @@ pub const Shaper = struct {
///
/// If there is not enough space in the cell buffer, an error is returned.
pub fn shape(self: *Shaper, run: font.shape.TextRun) ![]const font.shape.Cell {
const tracy = trace(@src());
defer tracy.end();
// We only do shaping if the font is not a special-case. For special-case
// fonts, the codepoint == glyph_index so we don't need to run any shaping.
if (run.font_index.special() == null) {

4
src/font/shaper/run.zig
View File

@ -4,7 +4,6 @@ const Allocator = std.mem.Allocator;
const font = @import("../main.zig");
const shape = @import("../shape.zig");
const terminal = @import("../../terminal/main.zig");
const trace = @import("tracy").trace;
/// A single text run. A text run is only valid for one Shaper instance and
/// until the next run is created. A text run never goes across multiple
@ -33,9 +32,6 @@ pub const RunIterator = struct {
i: usize = 0,
pub fn next(self: *RunIterator, alloc: Allocator) !?TextRun {
const tracy = trace(@src());
defer tracy.end();
// Trim the right side of a row that might be empty
const max: usize = max: {
var j: usize = self.row.lenCells();

16
src/main.zig
View File

@ -7,7 +7,6 @@ const glfw = @import("glfw");
const glslang = @import("glslang");
const macos = @import("macos");
const oni = @import("oniguruma");
const tracy = @import("tracy");
const cli = @import("cli.zig");
const internal_os = @import("os/main.zig");
const xev = @import("xev");
@ -167,7 +166,6 @@ pub const GlobalState = struct {
gpa: ?GPA,
alloc: std.mem.Allocator,
tracy: if (tracy.enabled) ?tracy.Allocator(null) else void,
action: ?cli.Action,
logging: Logging,
@ -189,7 +187,6 @@ pub const GlobalState = struct {
self.* = .{
.gpa = null,
.alloc = undefined,
.tracy = undefined,
.action = null,
.logging = .{ .stderr = {} },
.resources_dir = null,
@ -213,20 +210,13 @@ pub const GlobalState = struct {
break :gpa GPA{};
};
self.alloc = alloc: {
const base = if (self.gpa) |*value|
self.alloc = if (self.gpa) |*value|
value.allocator()
else if (builtin.link_libc)
std.heap.c_allocator
else
unreachable;
// If we're tracing, wrap the allocator
if (!tracy.enabled) break :alloc base;
self.tracy = tracy.allocator(base, null);
break :alloc self.tracy.?.allocator();
};
// We first try to parse any action that we may be executing.
self.action = try cli.Action.detectCLI(self.alloc);
@ -292,10 +282,6 @@ pub const GlobalState = struct {
// the point at which it will output if there were safety violations.
_ = value.deinit();
}
if (tracy.enabled) {
self.tracy = null;
}
}
};
test {

10
src/renderer/OpenGL.zig
View File

@ -19,7 +19,6 @@ const renderer = @import("../renderer.zig");
const terminal = @import("../terminal/main.zig");
const Terminal = terminal.Terminal;
const gl = @import("opengl");
const trace = @import("tracy").trace;
const math = @import("../math.zig");
const Surface = @import("../Surface.zig");
@ -946,9 +945,6 @@ pub fn rebuildCells(
cursor_style_: ?renderer.CursorStyle,
color_palette: *const terminal.color.Palette,
) !void {
const t = trace(@src());
defer t.end();
// Bg cells at most will need space for the visible screen size
self.cells_bg.clearRetainingCapacity();
try self.cells_bg.ensureTotalCapacity(self.alloc, screen.rows * screen.cols);
@ -1344,9 +1340,6 @@ fn updateCell(
x: usize,
y: usize,
) !bool {
const t = trace(@src());
defer t.end();
const BgFg = struct {
/// Background is optional because in un-inverted mode
/// it may just be equivalent to the default background in
@ -1781,9 +1774,6 @@ fn flushAtlas(self: *OpenGL) !void {
/// Render renders the current cell state. This will not modify any of
/// the cells.
pub fn drawFrame(self: *OpenGL, surface: *apprt.Surface) !void {
const t = trace(@src());
defer t.end();
// If we're in single-threaded more we grab a lock since we use shared data.
if (single_threaded_draw) self.draw_mutex.lock();
defer if (single_threaded_draw) self.draw_mutex.unlock();

15
src/renderer/Thread.zig
View File

@ -9,8 +9,6 @@ const renderer = @import("../renderer.zig");
const apprt = @import("../apprt.zig");
const configpkg = @import("../config.zig");
const BlockingQueue = @import("../blocking_queue.zig").BlockingQueue;
const tracy = @import("tracy");
const trace = tracy.trace;
const App = @import("../App.zig");
const Allocator = std.mem.Allocator;
@ -177,7 +175,6 @@ pub fn threadMain(self: *Thread) void {
fn threadMain_(self: *Thread) !void {
defer log.debug("renderer thread exited", .{});
tracy.setThreadName("renderer");
// Run our thread start/end callbacks. This is important because some
// renderers have to do per-thread setup. For example, OpenGL has to set
@ -242,9 +239,6 @@ fn stopDrawTimer(self: *Thread) void {
/// Drain the mailbox.
fn drainMailbox(self: *Thread) !void {
const zone = trace(@src());
defer zone.end();
while (self.mailbox.pop()) |message| {
log.debug("mailbox message={}", .{message});
switch (message) {
@ -358,9 +352,6 @@ fn wakeupCallback(
return .rearm;
};
const zone = trace(@src());
defer zone.end();
const t = self_.?;
// When we wake up, we check the mailbox. Mailbox producers should
@ -425,9 +416,6 @@ fn renderCallback(
_: *xev.Completion,
r: xev.Timer.RunError!void,
) xev.CallbackAction {
const zone = trace(@src());
defer zone.end();
_ = r catch unreachable;
const t = self_ orelse {
// This shouldn't happen so we log it.
@ -470,9 +458,6 @@ fn cursorTimerCallback(
_: *xev.Completion,
r: xev.Timer.RunError!void,
) xev.CallbackAction {
const zone = trace(@src());
defer zone.end();
_ = r catch |err| switch (err) {
// This is sent when our timer is canceled. That's fine.
error.Canceled => return .disarm,

4
src/terminal/Parser.zig
View File

@ -6,7 +6,6 @@ const Parser = @This();
const std = @import("std");
const builtin = @import("builtin");
const trace = @import("tracy").trace;
const testing = std.testing;
const table = @import("parse_table.zig").table;
const osc = @import("osc.zig");
@ -231,9 +230,6 @@ pub fn deinit(self: *Parser) void {
/// Up to 3 actions may need to be executed -- in order -- representing
/// the state exit, transition, and entry actions.
pub fn next(self: *Parser, c: u8) [3]?Action {
const tracy = trace(@src());
defer tracy.end();
// If we're processing UTF-8, we handle this manually.
if (self.state == .utf8) {
return .{ self.next_utf8(c), null, null };

19
src/terminal/Screen.zig
View File

@ -58,7 +58,6 @@ const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const ziglyph = @import("ziglyph");
const trace = @import("tracy").trace;
const ansi = @import("ansi.zig");
const modes = @import("modes.zig");
const sgr = @import("sgr.zig");
@ -803,9 +802,6 @@ pub const RowIndexTag = enum {
/// so it is 1-indexed. If the value is zero, it means that this
/// section of the screen is empty or disabled.
pub inline fn maxLen(self: RowIndexTag, screen: *const Screen) usize {
const tracy = trace(@src());
defer tracy.end();
return switch (self) {
// Screen can be any of the written rows
.screen => screen.rowsWritten(),
@ -1177,9 +1173,6 @@ pub fn getCellPtr(self: *Screen, tag: RowIndexTag, y: usize, x: usize) *Cell {
/// from index zero of the given row index type. This can therefore iterate
/// from row 0 of the active area, history, viewport, etc.
pub fn rowIterator(self: *Screen, tag: RowIndexTag) RowIterator {
const tracy = trace(@src());
defer tracy.end();
return .{
.screen = self,
.tag = tag,
@ -1234,9 +1227,6 @@ pub fn getLine(self: *Screen, pt: point.ScreenPoint) ?Line {
/// Returns the row at the given index. This row is writable, although
/// only the active area should probably be written to.
pub fn getRow(self: *Screen, index: RowIndex) Row {
const tracy = trace(@src());
defer tracy.end();
// Get our offset into storage
const offset = index.toScreen(self).screen * (self.cols + 1);
@ -1288,9 +1278,6 @@ pub fn copyRow(self: *Screen, dst: RowIndex, src: RowIndex) !void {
///
/// This can be used to implement terminal scroll regions efficiently.
pub fn scrollRegionUp(self: *Screen, top: RowIndex, bottom: RowIndex, count_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
// Avoid a lot of work if we're doing nothing.
if (count_req == 0) return;
@ -2091,9 +2078,6 @@ fn scrollRow(self: *Screen, idx: RowIndex) void {
}
fn scrollDelta(self: *Screen, delta: isize, viewport_only: bool) Allocator.Error!void {
const tracy = trace(@src());
defer tracy.end();
// Just in case, to avoid a bunch of stuff below.
if (delta == 0) return;
@ -2585,9 +2569,6 @@ fn selectionSlices(self: *Screen, sel_raw: Selection) SelectionSlices {
/// be truncated as they are shrunk. If they are grown, the new space is filled
/// with zeros.
pub fn resizeWithoutReflow(self: *Screen, rows: usize, cols: usize) !void {
const tracy = trace(@src());
defer tracy.end();
// If we're resizing to the same size, do nothing.
if (self.cols == cols and self.rows == rows) return;

100
src/terminal/Terminal.zig
View File

@ -18,7 +18,6 @@ const csi = @import("csi.zig");
const kitty = @import("kitty.zig");
const sgr = @import("sgr.zig");
const Tabstops = @import("Tabstops.zig");
const trace = @import("tracy").trace;
const color = @import("color.zig");
const Screen = @import("Screen.zig");
const mouse_shape = @import("mouse_shape.zig");
@ -213,9 +212,6 @@ pub fn alternateScreen(
alloc: Allocator,
options: AlternateScreenOptions,
) void {
const tracy = trace(@src());
defer tracy.end();
//log.info("alt screen active={} options={} cursor={}", .{ self.active_screen, options, self.screen.cursor });
// TODO: test
@ -255,9 +251,6 @@ pub fn primaryScreen(
alloc: Allocator,
options: AlternateScreenOptions,
) void {
const tracy = trace(@src());
defer tracy.end();
//log.info("primary screen active={} options={}", .{ self.active_screen, options });
// TODO: test
@ -296,9 +289,6 @@ pub const DeccolmMode = enum(u1) {
/// with the window. This will fix the grid at either 80 or 132 columns.
/// The rows will continue to be variable.
pub fn deccolm(self: *Terminal, alloc: Allocator, mode: DeccolmMode) !void {
const tracy = trace(@src());
defer tracy.end();
// If DEC mode 40 isn't enabled, then this is ignored. We also make
// sure that we don't have deccolm set because we want to fully ignore
// set mode.
@ -327,9 +317,6 @@ pub fn deccolm(self: *Terminal, alloc: Allocator, mode: DeccolmMode) !void {
/// Resize the underlying terminal.
pub fn resize(self: *Terminal, alloc: Allocator, cols: usize, rows: usize) !void {
const tracy = trace(@src());
defer tracy.end();
// If our cols/rows didn't change then we're done
if (self.cols == cols and self.rows == rows) return;
@ -469,9 +456,6 @@ pub fn restoreCursor(self: *Terminal) void {
/// TODO: test
pub fn setAttribute(self: *Terminal, attr: sgr.Attribute) !void {
const tracy = trace(@src());
defer tracy.end();
switch (attr) {
.unset => {
self.screen.cursor.pen.fg = .none;
@ -732,9 +716,6 @@ pub fn printString(self: *Terminal, str: []const u8) !void {
}
pub fn print(self: *Terminal, c: u21) !void {
const tracy = trace(@src());
defer tracy.end();
// log.debug("print={x} y={} x={}", .{ c, self.screen.cursor.y, self.screen.cursor.x });
// If we're not on the main display, do nothing for now
@ -971,9 +952,6 @@ pub fn print(self: *Terminal, c: u21) !void {
}
fn printCell(self: *Terminal, unmapped_c: u21) *Screen.Cell {
// const tracy = trace(@src());
// defer tracy.end();
const c: u21 = c: {
// TODO: non-utf8 handling, gr
@ -1034,9 +1012,6 @@ fn printCell(self: *Terminal, unmapped_c: u21) *Screen.Cell {
}
fn printWrap(self: *Terminal) !void {
const tracy = trace(@src());
defer tracy.end();
const row = self.screen.getRow(.{ .active = self.screen.cursor.y });
row.setWrapped(true);
@ -1068,9 +1043,6 @@ pub fn printRepeat(self: *Terminal, count_req: usize) !void {
///
/// Sets the cursor to the top left corner.
pub fn decaln(self: *Terminal) !void {
const tracy = trace(@src());
defer tracy.end();
// Reset margins, also sets cursor to top-left
self.scrolling_region = .{
.top = 0,
@ -1117,9 +1089,6 @@ pub fn decaln(self: *Terminal) !void {
///
/// This unsets the pending wrap state without wrapping.
pub fn index(self: *Terminal) !void {
const tracy = trace(@src());
defer tracy.end();
// Unset pending wrap state
self.screen.cursor.pending_wrap = false;
@ -1170,9 +1139,6 @@ pub fn index(self: *Terminal) !void {
/// * If the cursor is not on the top-most line of the scrolling region:
/// move the cursor one line up
pub fn reverseIndex(self: *Terminal) !void {
const tracy = trace(@src());
defer tracy.end();
if (self.screen.cursor.y != self.scrolling_region.top or
self.screen.cursor.x < self.scrolling_region.left or
self.screen.cursor.x > self.scrolling_region.right)
@ -1191,9 +1157,6 @@ pub fn reverseIndex(self: *Terminal) !void {
// greater than the bottom-most row it is adjusted to the bottom-most
// row.
pub fn setCursorPos(self: *Terminal, row_req: usize, col_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
// If cursor origin mode is set the cursor row will be moved relative to
// the top margin row and adjusted to be above or at bottom-most row in
// the current scroll region.
@ -1233,9 +1196,6 @@ pub fn eraseDisplay(
mode: csi.EraseDisplay,
protected_req: bool,
) void {
const tracy = trace(@src());
defer tracy.end();
// Erasing clears all attributes / colors _except_ the background
const pen: Screen.Cell = switch (self.screen.cursor.pen.bg) {
.none => .{},
@ -1384,9 +1344,6 @@ pub fn eraseLine(
mode: csi.EraseLine,
protected_req: bool,
) void {
const tracy = trace(@src());
defer tracy.end();
// We always fill with the background
const pen: Screen.Cell = switch (self.screen.cursor.pen.bg) {
.none => .{},
@ -1463,9 +1420,6 @@ pub fn eraseLine(
///
/// Does not change the cursor position.
pub fn deleteChars(self: *Terminal, count: usize) !void {
const tracy = trace(@src());
defer tracy.end();
if (count == 0) return;
// If our cursor is outside the margins then do nothing. We DO reset
@ -1510,9 +1464,6 @@ pub fn deleteChars(self: *Terminal, count: usize) !void {
}
pub fn eraseChars(self: *Terminal, count_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
const count = @max(count_req, 1);
// This resets the pending wrap state
@ -1556,9 +1507,6 @@ pub fn eraseChars(self: *Terminal, count_req: usize) void {
/// Move the cursor to the left amount cells. If amount is 0, adjust it to 1.
pub fn cursorLeft(self: *Terminal, count_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
// Wrapping behavior depends on various terminal modes
const WrapMode = enum { none, reverse, reverse_extended };
const wrap_mode: WrapMode = wrap_mode: {
@ -1665,9 +1613,6 @@ pub fn cursorLeft(self: *Terminal, count_req: usize) void {
/// This sequence will not scroll the screen or scroll region. If amount is
/// 0, adjust it to 1.
pub fn cursorRight(self: *Terminal, count_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
// Always resets pending wrap
self.screen.cursor.pending_wrap = false;
@ -1685,9 +1630,6 @@ pub fn cursorRight(self: *Terminal, count_req: usize) void {
/// move distance then it is internally adjusted to the maximum. This sequence
/// will not scroll the screen or scroll region. If amount is 0, adjust it to 1.
pub fn cursorDown(self: *Terminal, count_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
// Always resets pending wrap
self.screen.cursor.pending_wrap = false;
@ -1705,9 +1647,6 @@ pub fn cursorDown(self: *Terminal, count_req: usize) void {
/// move distance then it is internally adjusted to the maximum. If amount is
/// 0, adjust it to 1.
pub fn cursorUp(self: *Terminal, count_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
// Always resets pending wrap
self.screen.cursor.pending_wrap = false;
@ -1723,18 +1662,12 @@ pub fn cursorUp(self: *Terminal, count_req: usize) void {
/// Backspace moves the cursor back a column (but not less than 0).
pub fn backspace(self: *Terminal) void {
const tracy = trace(@src());
defer tracy.end();
self.cursorLeft(1);
}
/// Horizontal tab moves the cursor to the next tabstop, clearing
/// the screen to the left the tabstop.
pub fn horizontalTab(self: *Terminal) !void {
const tracy = trace(@src());
defer tracy.end();
while (self.screen.cursor.x < self.scrolling_region.right) {
// Move the cursor right
self.screen.cursor.x += 1;
@ -1748,9 +1681,6 @@ pub fn horizontalTab(self: *Terminal) !void {
// Same as horizontalTab but moves to the previous tabstop instead of the next.
pub fn horizontalTabBack(self: *Terminal) !void {
const tracy = trace(@src());
defer tracy.end();
// With origin mode enabled, our leftmost limit is the left margin.
const left_limit = if (self.modes.get(.origin)) self.scrolling_region.left else 0;
@ -1786,9 +1716,6 @@ pub fn tabReset(self: *Terminal) void {
/// Carriage return moves the cursor to the first column.
pub fn carriageReturn(self: *Terminal) void {
const tracy = trace(@src());
defer tracy.end();
// Always reset pending wrap state
self.screen.cursor.pending_wrap = false;
@ -1803,9 +1730,6 @@ pub fn carriageReturn(self: *Terminal) void {
/// Linefeed moves the cursor to the next line.
pub fn linefeed(self: *Terminal) !void {
const tracy = trace(@src());
defer tracy.end();
try self.index();
if (self.modes.get(.linefeed)) self.carriageReturn();
}
@ -1818,9 +1742,6 @@ pub fn linefeed(self: *Terminal) !void {
///
/// The inserted cells are colored according to the current SGR state.
pub fn insertBlanks(self: *Terminal, count: usize) void {
const tracy = trace(@src());
defer tracy.end();
// Unset pending wrap state without wrapping. Note: this purposely
// happens BEFORE the scroll region check below, because that's what
// xterm does.
@ -1901,9 +1822,6 @@ pub fn insertBlanks(self: *Terminal, count: usize) void {
///
/// Moves the cursor to the left margin.
pub fn insertLines(self: *Terminal, count: usize) !void {
const tracy = trace(@src());
defer tracy.end();
// Rare, but happens
if (count == 0) return;
@ -1965,9 +1883,6 @@ pub fn insertLines(self: *Terminal, count: usize) !void {
///
/// Moves the cursor to the left margin.
pub fn deleteLines(self: *Terminal, count: usize) !void {
const tracy = trace(@src());
defer tracy.end();
// If the cursor is outside the scroll region we do nothing.
if (self.screen.cursor.y < self.scrolling_region.top or
self.screen.cursor.y > self.scrolling_region.bottom or
@ -2024,9 +1939,6 @@ pub fn deleteLines(self: *Terminal, count: usize) !void {
/// Scroll the text down by one row.
pub fn scrollDown(self: *Terminal, count: usize) !void {
const tracy = trace(@src());
defer tracy.end();
// Preserve the cursor
const cursor = self.screen.cursor;
defer self.screen.cursor = cursor;
@ -2045,9 +1957,6 @@ pub fn scrollDown(self: *Terminal, count: usize) !void {
///
/// Does not change the (absolute) cursor position.
pub fn scrollUp(self: *Terminal, count: usize) !void {
const tracy = trace(@src());
defer tracy.end();
// Preserve the cursor
const cursor = self.screen.cursor;
defer self.screen.cursor = cursor;
@ -2072,9 +1981,6 @@ pub const ScrollViewport = union(enum) {
/// Scroll the viewport of the terminal grid.
pub fn scrollViewport(self: *Terminal, behavior: ScrollViewport) !void {
const tracy = trace(@src());
defer tracy.end();
try self.screen.scroll(switch (behavior) {
.top => .{ .top = {} },
.bottom => .{ .bottom = {} },
@ -2095,9 +2001,6 @@ pub fn scrollViewport(self: *Terminal, behavior: ScrollViewport) !void {
///
/// Top and bottom are 1-indexed.
pub fn setTopAndBottomMargin(self: *Terminal, top_req: usize, bottom_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
const top = @max(1, top_req);
const bottom = @min(self.rows, if (bottom_req == 0) self.rows else bottom_req);
if (top >= bottom) return;
@ -2109,9 +2012,6 @@ pub fn setTopAndBottomMargin(self: *Terminal, top_req: usize, bottom_req: usize)
/// DECSLRM
pub fn setLeftAndRightMargin(self: *Terminal, left_req: usize, right_req: usize) void {
const tracy = trace(@src());
defer tracy.end();
// We must have this mode enabled to do anything
if (!self.modes.get(.enable_left_and_right_margin)) return;

11
src/terminal/stream.zig
View File

@ -8,7 +8,6 @@ const kitty = @import("kitty.zig");
const modes = @import("modes.zig");
const osc = @import("osc.zig");
const sgr = @import("sgr.zig");
const trace = @import("tracy").trace;
const MouseShape = @import("mouse_shape.zig").MouseShape;
const log = std.log.scoped(.stream);
@ -44,17 +43,11 @@ pub fn Stream(comptime Handler: type) type {
/// Process a string of characters.
pub fn nextSlice(self: *Self, c: []const u8) !void {
const tracy = trace(@src());
defer tracy.end();
for (c) |single| try self.next(single);
}
/// Process the next character and call any callbacks if necessary.
pub fn next(self: *Self, c: u8) !void {
const tracy = trace(@src());
tracy.value(@as(u64, @intCast(c)));
defer tracy.end();
// log.debug("char: {c}", .{c});
const actions = self.parser.next(c);
for (actions) |action_opt| {
@ -108,10 +101,6 @@ pub fn Stream(comptime Handler: type) type {
}
pub fn execute(self: *Self, c: u8) !void {
const tracy = trace(@src());
tracy.value(@as(u64, @intCast(c)));
defer tracy.end();
switch (@as(ansi.C0, @enumFromInt(c))) {
// We ignore SOH/STX: https://github.com/microsoft/terminal/issues/10786
.NUL, .SOH, .STX => {},

5
src/termio/Exec.zig
View File

@ -16,8 +16,6 @@ const terminal = @import("../terminal/main.zig");
const terminfo = @import("../terminfo/main.zig");
const xev = @import("xev");
const renderer = @import("../renderer.zig");
const tracy = @import("tracy");
const trace = tracy.trace;
const apprt = @import("../apprt.zig");
const fastmem = @import("../fastmem.zig");
const internal_os = @import("../os/main.zig");
@ -1514,9 +1512,6 @@ const ReadThread = struct {
ev: *EventData,
buf: []const u8,
) void {
const zone = trace(@src());
defer zone.end();
// log.info("DATA: {d}", .{n});
// log.info("DATA: {any}", .{buf[0..@intCast(usize, n)]});

9
src/termio/Thread.zig
View File

@ -7,8 +7,6 @@ const builtin = @import("builtin");
const xev = @import("xev");
const termio = @import("../termio.zig");
const BlockingQueue = @import("../blocking_queue.zig").BlockingQueue;
const tracy = @import("tracy");
const trace = tracy.trace;
const Allocator = std.mem.Allocator;
const log = std.log.scoped(.io_thread);
@ -142,7 +140,6 @@ pub fn threadMain(self: *Thread) void {
fn threadMain_(self: *Thread) !void {
defer log.debug("IO thread exited", .{});
tracy.setThreadName("pty io");
// Run our thread start/end callbacks. This allows the implementation
// to hook into the event loop as needed.
@ -162,9 +159,6 @@ fn threadMain_(self: *Thread) !void {
/// Drain the mailbox, handling all the messages in our terminal implementation.
fn drainMailbox(self: *Thread) !void {
const zone = trace(@src());
defer zone.end();
// This holds the mailbox lock for the duration of the drain. The
// expectation is that all our message handlers will be non-blocking
// ENOUGH to not mess up throughput on producers.
@ -290,9 +284,6 @@ fn wakeupCallback(
return .rearm;
};
const zone = trace(@src());
defer zone.end();
const t = self_.?;
// When we wake up, we check the mailbox. Mailbox producers should