separate ted-internal.h

1 files changed, 788 insertions, 0 deletions

diff --git a/ted-internal.h b/ted-internal.h
new file mode 100644
index 0000000..2761557
--- /dev/null
+++ b/ted-internal.h
@@ -0,0 +1,788 @@
+/// \file
+///
+/// this file is included by (almost) all of ted's source files.
+/// it may change arbitrarily so plugin authors should not include it!
+
+#ifndef TED_INTERNAL_H_
+#define TED_INTERNAL_H_
+
+#include "ted.h"
+#include "lsp.h"
+#include "os.h"
+#include "unicode.h"
+#include "ds.h"
+#include "sdl-inc.h"
+#include "lib/glcorearb.h"
+
+/// Minimum text size
+#define TEXT_SIZE_MIN 6
+/// Maximum text size
+#define TEXT_SIZE_MAX 70
+/// max number of LSPs running at once
+#define TED_LSP_MAX 200
+/// max number of macros
+#define TED_MACRO_MAX 256
+
+/// Version string
+#define TED_VERSION_FULL "ted v. " TED_VERSION
+
+typedef struct {
+	const char *string;
+	i64 number;
+} CommandArgument;
+
+typedef struct {
+	// did this command come from executing a macro?
+	bool running_macro;
+} CommandContext;
+
+/// Thing to do when a key combo is pressed.
+typedef struct {
+	KeyCombo key_combo;
+	Command command;
+	CommandArgument argument;
+} KeyAction;
+
+
+/// A SettingsContext is a context where a specific set of settings are applied.
+/// this corresponds to `[PATH//LANGUAGE.(section)]` in config files.
+typedef struct {
+	/// The settings apply to this language.
+	Language language;
+	/// The settings apply to all paths which start with this string, or all paths if path=NULL
+	char *path;
+} SettingsContext;
+
+/// Need to use reference counting for textures because of Settings:
+/// We copy parent settings to children
+/// e.g.
+/// ```
+/// [core]
+/// bg-texture = "blablabla.png"
+/// [Javascript.core]
+/// some random shit
+/// ```
+/// the main Settings' bg_texture will get copied to javascript's Settings,
+/// so we need to be extra careful about when we delete textures.
+typedef struct {
+	u32 ref_count;
+	GLuint texture;
+} GlRcTexture;
+
+/// Reference-counted shader-array-buffer combo.
+typedef struct {
+	u32 ref_count;
+	GLuint shader;
+	GLuint array;
+	GLuint buffer;
+} GlRcSAB;
+
+typedef struct {
+	Language language;
+	char extension[16];
+} LanguageExtension;
+
+/// All of ted's settings
+///
+/// NOTE: to add more options to ted, add fields here,
+/// and change the settings_<type> global constant near the top of config.c	
+struct Settings {
+	SettingsContext context;
+	u32 colors[COLOR_COUNT];
+	float cursor_blink_time_on, cursor_blink_time_off;
+	float hover_time;
+	float ctrl_scroll_adjust_text_size;
+	u32 max_file_size;
+	u32 max_file_size_view_only;
+	u16 framerate_cap;
+	u16 text_size_no_dpi;
+	u16 text_size;
+	u16 max_menu_width;
+	u16 error_display_time;
+	bool auto_indent;
+	bool auto_add_newline;
+	bool syntax_highlighting;
+	bool line_numbers;
+	bool auto_reload;
+	bool auto_reload_config;
+	bool restore_session;
+	bool regenerate_tags_if_not_found;
+	bool indent_with_spaces;
+	bool phantom_completions;
+	bool trigger_characters;
+	bool identifier_trigger_characters;
+	bool signature_help_enabled;
+	bool lsp_enabled;
+	bool lsp_log;
+	bool hover_enabled;
+	bool highlight_enabled;
+	bool highlight_auto;
+	bool document_links;
+	bool vsync;
+	bool save_backup;
+	bool crlf_windows;
+	bool jump_to_build_error;
+	bool force_monospace;
+	KeyCombo hover_key;
+	KeyCombo highlight_key;
+	u8 tab_width;
+	u8 cursor_width;
+	u8 undo_save_time;
+	u8 border_thickness;
+	u8 padding;
+	u8 scrolloff;
+	u8 tags_max_depth;
+	GlRcSAB *bg_shader;
+	GlRcTexture *bg_texture;
+	/// string used to start comments
+	char comment_start[16];
+	/// string used to end comments
+	char comment_end[16];
+	/// Comma-separated list of file names which identify the project root
+	char root_identifiers[4096];
+	/// LSP server command
+	char lsp[512];
+	/// LSP "configuration" JSON
+	char lsp_configuration[4096];
+	/// Build command. If non-empty, this overrides running `cargo build` if `Cargo.toml` exists, etc.
+	char build_command[1024];
+	/// Default build command for if `Cargo.toml`, `Makefile`, etc. do not exist.
+	char build_default_command[1024];
+	/// Comma separated list of paths to font files.
+	char font[4096];
+	/// Comma separated list of paths to bold font files.
+	char font_bold[4096];
+	LanguageExtension *language_extensions;
+	/// dynamic array, sorted by KEY_COMBO(modifier, key)
+	KeyAction *key_actions;
+};
+
+/// A single line in a buffer
+typedef struct Line Line;
+
+/// This structure is used temporarily when loading settings
+/// It's needed because we want more specific contexts to be dealt with last.
+typedef struct ConfigPart ConfigPart;
+
+/// A single undoable edit to a buffer
+typedef struct BufferEdit BufferEdit;
+
+struct TextBuffer {
+	/// NULL if this buffer is untitled or doesn't correspond to a file (e.g. line buffers)
+	char *path;
+	/// we keep a back-pointer to the ted instance so we don't have to pass it in to every buffer function
+	struct Ted *ted;
+	/// number of characters scrolled in the x direction (multiply by space width to get pixels)
+	double scroll_x;
+	/// number of characters scrolled in the y direction
+	double scroll_y;
+	/// last write time to \ref path
+	double last_write_time;
+	/// the language the buffer has been manually set to, or \ref LANG_NONE if it hasn't been set to anything
+	i64 manual_language;
+	/// position of cursor
+	BufferPos cursor_pos;
+	/// if \ref selection is true, the text between \ref selection_pos and \ref cursor_pos is selected.
+	BufferPos selection_pos;
+	/// "previous" position of cursor, for \ref CMD_PREVIOUS_POSITION
+	BufferPos prev_cursor_pos;
+	/// "line buffers" are buffers which can only have one line of text (used for inputs)
+	bool is_line_buffer;
+	/// is anything selected?
+	bool selection;
+	/// set to false to disable undo events
+	bool store_undo_events;
+	/// This is set to true whenever a change is made to the buffer, and never set to false by buffer_ functions.
+	/// (Distinct from \ref buffer_unsaved_changes)
+	bool modified;
+	/// will the next undo event be chained with the ones after?
+	bool will_chain_edits;
+	/// will the next undo event be chained with the previous one?
+	bool chaining_edits;
+	/// view-only mode
+	bool view_only;
+	/// (line buffers only) set to true when submitted. you have to reset it to false.
+	bool line_buffer_submitted;
+	/// If set to true, buffer will be scrolled to the cursor position next frame.
+	/// This is to fix the problem that \ref x1, \ref y1, \ref x2, \ref y2 are not updated until the buffer is rendered.
+	bool center_cursor_next_frame;
+	/// x coordinate of left side of buffer
+	float x1;
+	/// y coordinate of top side of buffer
+	float y1;
+	/// x coordinate of right side of buffer
+	float x2;
+	/// y coordinate of bottom side of buffer
+	float y2;
+	/// number of lines in buffer
+	u32 nlines;
+	/// capacity of \ref lines
+	u32 lines_capacity;
+	
+	/// cached settings index (into ted->all_settings), or -1 if has not been computed yet
+	i32 settings_idx;
+	
+	/// which LSP this document is open in
+	LSPID lsp_opened_in;
+	/// determining which LSP to use for a buffer takes some work,
+	/// so we don't want to do it every single frame.
+	/// this keeps track of the last time we actually checked what the correct LSP is.
+	double last_lsp_check;
+
+	/// where in the undo history was the last write? used by \ref buffer_unsaved_changes
+	u32 undo_history_write_pos;
+	/// which lines are on screen? updated when \ref buffer_render is called.
+	u32 first_line_on_screen, last_line_on_screen;
+
+	/// to cache syntax highlighting properly, it is important to keep track of the
+	/// first and last line modified since last frame.
+	u32 frame_earliest_line_modified;
+	/// see \ref frame_earliest_line_modified.
+	u32 frame_latest_line_modified;
+
+	/// lines
+	Line *lines;
+	/// last error
+	char error[256];
+	/// dynamic array of undo history
+	BufferEdit *undo_history;
+	/// dynamic array of redo history
+	BufferEdit *redo_history;
+};
+
+/// an entry in a selector menu (e.g. the "open" menu)
+typedef struct {
+	/// label
+	const char *name;
+	/// if not NULL, this will show on the right side of the entry.
+	const char *detail;
+	/// color to draw text in
+	u32 color;
+	/// use this for whatever you want
+	u64 userdata;
+} SelectorEntry;
+
+struct Selector {
+	SelectorEntry *entries;
+	u32 n_entries;
+	Rect bounds;
+	/// index where the selector thing is
+	u32 cursor;
+	float scroll;
+	/// whether or not we should let the user select entries using a cursor.
+	bool enable_cursor;
+};
+
+/// file entries for file selectors
+typedef struct {
+	/// just the file name
+	char *name;
+	/// full path
+	char *path;
+	FsType type;
+} FileEntry;
+
+struct FileSelector {
+	Selector sel;
+	Rect bounds;
+	u32 n_entries;
+	FileEntry *entries;
+	char cwd[TED_PATH_MAX];
+	/// indicates that this is for creating files, not opening files
+	bool create_menu;
+};
+
+// A node is a collection of tabs OR a split of two node
+struct Node {
+	/// dynamic array of indices into ted->buffers, or `NULL` if this is a split
+	u16 *tabs;
+	/// number from 0 to 1 indicating where the split is.
+	float split_pos;
+	/// index of active tab in `tabs`.
+	u16 active_tab;
+	/// is the split vertical? if false, this split looks like a|b
+	bool split_vertical;
+	/// split left/upper half; index into `ted->nodes`
+	u16 split_a;
+	/// split right/lower half
+	u16 split_b;
+};
+
+/// max number of buffers open at one time
+#define TED_MAX_BUFFERS 256
+/// max number of nodes open at one time
+#define TED_MAX_NODES 256
+/// max tabs per node
+#define TED_MAX_TABS 100
+/// max strings in all config files
+#define TED_MAX_STRINGS 1000
+
+/// "find" menu result
+typedef struct FindResult FindResult;
+
+typedef struct {
+	char *path;
+	u32 line;
+	u32 column;
+	/// if this is 1, then column == UTF-32 index.
+	/// if this is 4, for example, then column 4 in a line starting with a tab would
+	/// be the character right after the tab.
+	u8 columns_per_tab;
+	/// which line in the build output corresponds to this error
+	u32 build_output_line;
+} BuildError;
+
+/// `LSPSymbolKind`s are translated to these. this is a much coarser categorization
+typedef enum {
+	SYMBOL_OTHER,
+	SYMBOL_FUNCTION,
+	SYMBOL_FIELD,
+	SYMBOL_TYPE,
+	SYMBOL_VARIABLE,
+	SYMBOL_CONSTANT,
+	SYMBOL_KEYWORD
+} SymbolKind;
+
+/// data needed for autocompletion
+typedef struct Autocomplete Autocomplete;
+
+/// data needed for finding usages
+typedef struct Usages Usages;
+
+/// max number of signatures to display at a time.
+#define SIGNATURE_HELP_MAX 5
+
+/// "signature help" (LSP) is thing that shows the current parameter, etc.
+typedef struct SignatureHelp SignatureHelp;
+
+
+/// "document link" information (LSP)
+typedef struct DocumentLinks DocumentLinks;
+
+/// information for symbol rename (LSP)
+typedef struct RenameSymbol RenameSymbol;
+
+/// "hover" information from LSP server
+typedef struct Hover Hover;
+
+/// symbol information for the definitions menu
+typedef struct {
+	char *name;
+	char *detail;
+	u32 color;
+	/// is this from a LSP server (as opposed to ctags)?
+	bool from_lsp;
+	/// only set if `from_lsp = true`
+	LSPDocumentPosition position;
+} SymbolInfo;
+
+typedef struct {
+	LSPServerRequestID last_request;
+	double last_request_time;	
+	/// last query string which we sent a request for
+	char *last_request_query;
+	/// for "go to definition of..." menu
+	Selector selector;
+	/// an array of all definitions (gotten from workspace/symbols) for "go to definition" menu
+	SymbolInfo *all_definitions;
+} Definitions;
+
+/// "highlight" information from LSP server
+typedef struct Highlights Highlights;
+
+typedef struct {
+	Command command;
+	CommandArgument argument;
+} Action;
+
+typedef struct {
+	// dynamic array
+	Action *actions;
+} Macro;
+
+typedef struct {
+	char *path;
+	Font *font;
+} LoadedFont;
+
+typedef struct {
+	vec2 pos;
+	u8 times;
+} MouseClick;
+
+typedef struct {
+	vec2 pos;
+} MouseRelease;
+
+struct Ted {
+	/// all running LSP servers
+	LSP *lsps[TED_LSP_MAX + 1];
+	/// current time (see time_get_seconds), as of the start of this frame
+	double frame_time;
+	
+	Macro macros[TED_MACRO_MAX];
+	Macro *recording_macro;
+	bool executing_macro;
+	
+	SDL_Window *window;
+	LoadedFont *all_fonts;
+	Font *font_bold;
+	Font *font;
+	TextBuffer *active_buffer;
+	/// buffer we are currently drag-to-selecting in, if any
+	TextBuffer *drag_buffer;
+	/// while a menu or something is open, there is no active buffer. when the menu is closed,
+	/// the old active buffer needs to be restored. that's what this stores.
+	TextBuffer *prev_active_buffer; 
+	Node *active_node;
+	/// dynamic array of Settings. use Settings.context to figure out which one to use.
+	Settings *all_settings;
+	/// settings to use when no buffer is open
+	Settings *default_settings;
+	float window_width, window_height;
+	vec2 mouse_pos;
+	u32 mouse_state;
+	/// `mouse_clicks[SDL_BUTTON_RIGHT]`, for example, is all the right mouse-clicks that have happened this frame
+	MouseClick *mouse_clicks[4];
+	MouseRelease *mouse_releases[4];
+	/// total amount scrolled this frame
+	int scroll_total_x, scroll_total_y; 
+	/// currently open menu, or \ref MENU_NONE if no menu is open.
+	Menu menu;
+	FileSelector file_selector;
+	Selector command_selector;
+	/// general-purpose line buffer for inputs -- used for menus
+	TextBuffer line_buffer;
+	/// use for "find" term in find/find+replace
+	TextBuffer find_buffer;
+	/// "replace" for find+replace
+	TextBuffer replace_buffer;
+	/// buffer for build output (view only)
+	TextBuffer build_buffer;
+	/// used for command selector
+	TextBuffer argument_buffer;
+	/// time which the cursor error animation started (cursor turns red, e.g. when there's no autocomplete suggestion)
+	double cursor_error_time;
+	/// should start_cwd be searched for files? set to true if the executable isn't "installed"
+	bool search_start_cwd;
+	/// CWD `ted` was started in
+	char start_cwd[TED_PATH_MAX];
+	/// if set to true, the window will close next frame. NOTE: this doesn't check for unsaved changes!!
+	bool quit;
+	/// is the find or find+replace menu open?
+	bool find;
+	/// is the find+replace menu open?
+	bool replace;
+	/// find options
+	bool find_regex, find_case_sensitive;
+	/// flags used last time search term was compiled
+	u32 find_flags;
+	struct pcre2_real_code_32 *find_code;
+	struct pcre2_real_match_data_32 *find_match_data;
+	FindResult *find_results;
+	/// invalid regex?
+	bool find_invalid_pattern;
+	/// if non-zero, the user is trying to execute this command, but there are unsaved changes
+	Command warn_unsaved;
+	/// are we showing the build output?
+	bool build_shown;
+	/// is the build process running?
+	bool building;
+	Autocomplete *autocomplete;
+	SignatureHelp *signature_help;
+	DocumentLinks *document_links;
+	Hover *hover;
+	Definitions definitions;
+	Highlights *highlights;
+	Usages *usages;
+	RenameSymbol *rename_symbol;
+	
+	FILE *log;
+	
+	/// dynamic array of build errors
+	BuildError *build_errors;
+	/// build error we are currently "on"
+	u32 build_error;
+	
+	/// used by menus to keep track of the scroll position so we can return to it.
+	vec2d prev_active_buffer_scroll;
+	
+	SDL_Cursor *cursor_arrow, *cursor_ibeam, *cursor_wait,
+		*cursor_resize_h, *cursor_resize_v, *cursor_hand, *cursor_move;
+	/// which cursor to use this frame
+	/// this should be set to one of the cursor_* members above, or NULL for no cursor
+	SDL_Cursor *cursor;
+	
+	/// node containing tab user is dragging around, NULL if user is not dragging a tab
+	Node *dragging_tab_node;
+	/// index in dragging_tab_node->tabs
+	u16 dragging_tab_idx;
+	/// where the tab is being dragged from (i.e. mouse pos at start of drag action)
+	vec2 dragging_tab_origin;
+	
+	/// if not `NULL`, points to the node whose split the user is currently resizing.
+	Node *resizing_split;
+	
+	/// dynamic array of history of commands run with :shell (UTF-8)
+	char **shell_history;
+	/// for keeping track of where we are in the shell history.
+	u32 shell_history_pos;
+
+	// points to a selector if any is open, otherwise NULL.
+	Selector *selector_open;
+	
+	/// what % of the screen the build output takes up
+	float build_output_height;
+	bool resizing_build_output;
+	
+	/// last time a save command was executed. used for bg-shaders.
+	double last_save_time;
+
+	Process *build_process;
+	/// When we read the stdout from the build process, the tail end of the read could be an
+	/// incomplete UTF-8 code point. This is where we store that "tail end" until more
+	/// data is available. (This is up to 3 bytes, null terminated)
+	char build_incomplete_codepoint[4];
+	/// allows execution of multiple commands -- needed for tags generation
+	char **build_queue;
+	/// comma-separated list of files with unsaved changes (only applicable if warn_unsaved != 0)
+	char warn_unsaved_names[TED_PATH_MAX];
+	/// file name user is trying to overwrite
+	char warn_overwrite[TED_PATH_MAX];
+	/// file name which we want to reload
+	char ask_reload[TED_PATH_MAX];
+	char local_data_dir[TED_PATH_MAX];
+	char global_data_dir[TED_PATH_MAX];
+	/// home directory
+	char home[TED_PATH_MAX];
+	/// current working directory
+	char cwd[TED_PATH_MAX];
+	/// directory where we run the build command
+	char build_dir[TED_PATH_MAX];
+	/// where we are reading tags from
+	char tags_dir[TED_PATH_MAX];
+	bool nodes_used[TED_MAX_NODES];
+	/// `nodes[0]` is always the "root node", if any buffers are open.
+	Node nodes[TED_MAX_NODES];
+	/// NOTE: the buffer at index 0 is reserved as a "null buffer" and should not be used.
+	bool buffers_used[TED_MAX_BUFFERS];
+	TextBuffer buffers[TED_MAX_BUFFERS];
+	/// number of config file strings
+	u32 nstrings;
+	/// config file strings
+	char *strings[TED_MAX_STRINGS];
+	char window_title[256];
+	
+	/// little box used to display errors and info.
+	char message[512];
+	/// time message box was opened
+	double message_time;
+	MessageType message_type;
+	MessageType message_shown_type;
+	char message_shown[512];
+};
+
+// === buffer.c ===
+/// Get the LSPDocumentID corresponding to the file this buffer contains.
+/// The return value is only useful if `buffer_lsp(buffer) != NULL`.
+LSPDocumentID buffer_lsp_document_id(TextBuffer *buffer);
+/// Get LSPPosition corresponding to position in buffer.
+LSPPosition buffer_pos_to_lsp_position(TextBuffer *buffer, BufferPos pos);
+/// Get LSPDocumentPosition corresponding to position in buffer.
+LSPDocumentPosition buffer_pos_to_lsp_document_position(TextBuffer *buffer, BufferPos pos);
+/// Convert LSPPosition to BufferPos.
+BufferPos buffer_pos_from_lsp(TextBuffer *buffer, LSPPosition lsp_pos);
+/// Get the cursor position as an LSPPosition.
+LSPPosition buffer_cursor_pos_as_lsp_position(TextBuffer *buffer);
+/// Get the cursor position as an LSPDocumentPosition.
+LSPDocumentPosition buffer_cursor_pos_as_lsp_document_position(TextBuffer *buffer);
+/// highlight an \ref LSPRange in this buffer.
+///
+/// make sure to call \ref gl_geometry_draw after this
+void buffer_highlight_lsp_range(TextBuffer *buffer, LSPRange range, ColorSetting color);
+
+// === colors.c ====
+void color_init(void);
+/// which color setting should be used for the given symbol kind.
+/// this is the color used in the autocomplete selector, for example.
+ColorSetting color_for_symbol_kind(SymbolKind kind);
+
+// === command.c ===
+void command_init(void);
+void command_execute_ex(Ted *ted, Command c, const CommandArgument *argument, const CommandContext *context);
+
+// === config.c ===
+/// first, we read all config files, then we parse them.
+/// this is because we want less specific settings (e.g. settings applied
+/// to all languages instead of one particular language) to be applied first,
+/// then more specific settings are based off of those.
+///
+/// EXAMPLE:
+/// ```
+///   ---config file 1---
+///     [Javascript.core]
+///     syntax-highlighting = off
+///     (inherits tab-width = 4)
+///     [CSS.core]
+///     tab-width = 2 (overrides tab-width = 4)
+///   ---config file 2---
+///     [core]
+///     tab-width = 4
+/// ```
+void config_read(Ted *ted, ConfigPart **pparts, const char *filename);
+void config_parse(Ted *ted, ConfigPart **pparts);
+void config_free(Ted *ted);
+/// how well does this settings context fit the given path and language?
+/// the context with the highest score will be chosen.
+long context_score(const char *path, Language lang, const SettingsContext *context);
+
+// === gl.c ===
+/// set by main()
+extern float gl_window_width, gl_window_height;
+/// set by main()
+extern int gl_version_major, gl_version_minor;
+/// macro trickery to avoid having to write every GL function multiple times
+#define gl_for_each_proc(do)\
+	do(DRAWARRAYS, DrawArrays)\
+	do(GENTEXTURES, GenTextures)\
+	do(DELETETEXTURES, DeleteTextures)\
+	do(GENERATEMIPMAP, GenerateMipmap)\
+	do(TEXIMAGE2D, TexImage2D)\
+	do(BINDTEXTURE, BindTexture)\
+	do(TEXPARAMETERI, TexParameteri)\
+	do(GETERROR, GetError)\
+	do(GETINTEGERV, GetIntegerv)\
+	do(ENABLE, Enable)\
+	do(DISABLE, Disable)\
+	do(BLENDFUNC, BlendFunc)\
+	do(VIEWPORT, Viewport)\
+	do(CLEARCOLOR, ClearColor)\
+	do(CLEAR, Clear)\
+	do(FINISH, Finish)\
+	do(CREATESHADER, CreateShader)\
+	do(DELETESHADER, DeleteShader)\
+	do(CREATEPROGRAM, CreateProgram)\
+	do(SHADERSOURCE, ShaderSource)\
+	do(GETSHADERIV, GetShaderiv)\
+	do(GETSHADERINFOLOG, GetShaderInfoLog)\
+	do(COMPILESHADER, CompileShader)\
+	do(CREATEPROGRAM, CreateProgram)\
+	do(DELETEPROGRAM, DeleteProgram)\
+	do(ATTACHSHADER, AttachShader)\
+	do(LINKPROGRAM, LinkProgram)\
+	do(GETPROGRAMIV, GetProgramiv)\
+	do(GETPROGRAMINFOLOG, GetProgramInfoLog)\
+	do(USEPROGRAM, UseProgram)\
+	do(GETATTRIBLOCATION, GetAttribLocation)\
+	do(GETUNIFORMLOCATION, GetUniformLocation)\
+	do(GENBUFFERS, GenBuffers)\
+	do(DELETEBUFFERS, DeleteBuffers)\
+	do(BINDBUFFER, BindBuffer)\
+	do(BUFFERDATA, BufferData)\
+	do(VERTEXATTRIBPOINTER, VertexAttribPointer)\
+	do(ENABLEVERTEXATTRIBARRAY, EnableVertexAttribArray)\
+	do(DISABLEVERTEXATTRIBARRAY, DisableVertexAttribArray)\
+	do(GENVERTEXARRAYS, GenVertexArrays)\
+	do(DELETEVERTEXARRAYS, DeleteVertexArrays)\
+	do(BINDVERTEXARRAY, BindVertexArray)\
+	do(ACTIVETEXTURE, ActiveTexture)\
+	do(UNIFORM1F, Uniform1f)\
+	do(UNIFORM2F, Uniform2f)\
+	do(UNIFORM3F, Uniform3f)\
+	do(UNIFORM4F, Uniform4f)\
+	do(UNIFORM1I, Uniform1i)\
+	do(UNIFORM2I, Uniform2i)\
+	do(UNIFORM3I, Uniform3i)\
+	do(UNIFORM4I, Uniform4i)\
+	do(UNIFORMMATRIX4FV, UniformMatrix4fv)\
+	do(DEBUGMESSAGECALLBACK, DebugMessageCallback)\
+	do(DEBUGMESSAGECONTROL, DebugMessageControl)\
+
+#define gl_declare_proc(upper, lower) extern PFNGL##upper##PROC gl##lower;
+gl_for_each_proc(gl_declare_proc)
+#undef gl_declare_proc
+/// get addresses of GL functions
+void gl_get_procs(void);
+/// create a new reference-counted shader-array-buffer object.
+GlRcSAB *gl_rc_sab_new(GLuint shader, GLuint array, GLuint buffer);
+/// increase reference count on `s`.
+void gl_rc_sab_incref(GlRcSAB *s);
+/// decrease reference count on `*ps`, and set `*ps` to NULL if the reference count is 0.
+void gl_rc_sab_decref(GlRcSAB **ps);
+/// create a new reference-counted texture.
+GlRcTexture *gl_rc_texture_new(GLuint texture);
+/// increase reference count on `t`.
+void gl_rc_texture_incref(GlRcTexture *t);
+/// decrease reference count on `*t`, and set `*t` to NULL if the reference count is 0.
+void gl_rc_texture_decref(GlRcTexture **pt);
+/// initialize geometry stuff
+void gl_geometry_init(void);
+
+// === ide-autocomplete.c ===
+void autocomplete_init(Ted *ted);
+void autocomplete_quit(Ted *ted);
+void autocomplete_process_lsp_response(Ted *ted, const LSPResponse *response);
+
+// === ide-definitions.c ===
+/// go to the definition of `name`.
+/// if `lsp` is NULL, tags will be used.
+/// Note: the document position is required for LSP requests because of overloading (where the name
+/// alone isn't sufficient)
+void definition_goto(Ted *ted, LSP *lsp, const char *name, LSPDocumentPosition pos, GotoType type);
+void definitions_process_lsp_response(Ted *ted, LSP *lsp, const LSPResponse *response);
+
+// === ide-document-link.c ===
+void document_link_init(Ted *ted);
+void document_link_quit(Ted *ted);
+void document_link_frame(Ted *ted);
+void document_link_process_lsp_response(Ted *ted, const LSPResponse *response);
+
+// === ide-highlights.c ===
+void highlights_init(Ted *ted);
+void highlights_quit(Ted *ted);
+void highlights_frame(Ted *ted);
+void highlights_process_lsp_response(Ted *ted, const LSPResponse *response);
+
+// === ide-hover.c ===
+void hover_init(Ted *ted);
+void hover_frame(Ted *ted, double dt);
+void hover_process_lsp_response(Ted *ted, const LSPResponse *response);
+void hover_quit(Ted *ted);
+
+// === ide-rename-symbol.c ===
+void rename_symbol_init(Ted *ted);
+void rename_symbol_quit(Ted *ted);
+void rename_symbol_frame(Ted *ted);
+void rename_symbol_process_lsp_response(Ted *ted, const LSPResponse *response);
+
+// === ide-signature-help.c ===
+void signature_help_init(Ted *ted);
+void signature_help_quit(Ted *ted);
+void signature_help_frame(Ted *ted);
+void signature_help_process_lsp_response(Ted *ted, const LSPResponse *response);
+
+// === ide-usages.c ===
+void usages_init(Ted *ted);
+void usages_process_lsp_response(Ted *ted, const LSPResponse *response);
+void usages_frame(Ted *ted);
+void usages_quit(Ted *ted);
+
+// === macro.c ===
+void macro_add(Ted *ted, Command command, const CommandArgument *argument);
+
+// === tags.c ===
+/// get all tags in the tags file as SymbolInfos.
+SymbolInfo *tags_get_symbols(Ted *ted);
+
+// === ted.c ===
+/// Get LSP by ID. Returns NULL if there is no LSP with that ID.
+LSP *ted_get_lsp_by_id(Ted *ted, LSPID id);
+/// go to this LSP document position, opening a new buffer containing the file if necessary.
+void ted_go_to_lsp_document_position(Ted *ted, LSP *lsp, LSPDocumentPosition position);
+/// cancel this LSP request. also zeroes *request
+/// if *request is zeroed, this does nothing.
+void ted_cancel_lsp_request(Ted *ted, LSPServerRequestID *request);
+/// convert LSPWindowMessageType to MessageType
+MessageType ted_message_type_from_lsp(LSPWindowMessageType type);
+
+#endif // TED_INTERNAL_H_