562 lines
11 KiB
PHP
562 lines
11 KiB
PHP
<?php declare(strict_types=1);
|
|
|
|
namespace Aviat\Kilo;
|
|
|
|
use FFI;
|
|
|
|
use Aviat\Kilo\Enum\{
|
|
C,
|
|
Color,
|
|
Highlight,
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ! Terminal size
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* @TODO fix
|
|
*/
|
|
function get_cursor_position()
|
|
{
|
|
write_stdout("\x1b[999C\x1b[999B");
|
|
write_stdout("\x1b[6n");
|
|
|
|
$rows = 0;
|
|
$cols = 0;
|
|
|
|
$buffer = read_stdout();
|
|
|
|
$res = sscanf($buffer, '\x1b[%d;%dR', $rows, $cols);
|
|
|
|
if ($res === -1 || $buffer[0] !== '\x1b' || $buffer[1] !== '[')
|
|
{
|
|
die('Failed to get screen size');
|
|
}
|
|
|
|
return [$rows, $cols];
|
|
}
|
|
|
|
function get_window_size()
|
|
{
|
|
$ffi = get_ffi();
|
|
|
|
$ws = $ffi->new('struct winsize');
|
|
$res = $ffi->ioctl(C::STDOUT_FILENO, C::TIOCGWINSZ, FFI::addr($ws));
|
|
|
|
if ($res === -1 || $ws->ws_col === 0)
|
|
{
|
|
return get_cursor_position();
|
|
}
|
|
|
|
return [$ws->ws_row, $ws->ws_col];
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ! C function/macro equivalents
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Do bit twiddling to convert a letter into
|
|
* its Ctrl-letter equivalent ordinal ascii value
|
|
*
|
|
* @param string $char
|
|
* @return int
|
|
*/
|
|
function ctrl_key(string $char): int
|
|
{
|
|
if ( ! is_ascii($char))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// b1,100,001 (a) & b0,011,111 (0x1f) = b0,000,001 (SOH)
|
|
// b1,100,010 (b) & b0,011,111 (0x1f) = b0,000,010 (STX)
|
|
// ...and so on
|
|
return ord($char) & 0x1f;
|
|
}
|
|
|
|
/**
|
|
* Does the one-character string contain an ascii ordinal value?
|
|
*
|
|
* @param string $single_char
|
|
* @return bool
|
|
*/
|
|
function is_ascii(string $single_char): bool
|
|
{
|
|
if (strlen($single_char) > 1)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return ord($single_char) < 0x80;
|
|
}
|
|
|
|
/**
|
|
* Does the one-character string contain an ascii control character?
|
|
*
|
|
* @param string $char
|
|
* @return bool
|
|
*/
|
|
function is_cntrl(string $char): bool
|
|
{
|
|
$c = ord($char);
|
|
return is_ascii($char) && ( $c < 0x20 || $c === 0x7f );
|
|
}
|
|
|
|
/**
|
|
* Does the one-character string contain an ascii number?
|
|
*
|
|
* @param string $char
|
|
* @return bool
|
|
*/
|
|
function is_digit(string $char): bool
|
|
{
|
|
$c = ord($char);
|
|
return is_ascii($char) && ( $c > 0x2f && $c < 0x3a );
|
|
}
|
|
|
|
/**
|
|
* Does the one-character string contain ascii whitespace?
|
|
*
|
|
* @param string $char
|
|
* @return bool
|
|
*/
|
|
function is_space(string $char): bool
|
|
{
|
|
$ws = [' ', "\t", "\n", "\r", "\xa", "\xb", "\xc"];
|
|
return is_ascii($char) && in_array($char, $ws, TRUE);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ! Helper functions
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* A 'singleton' function to replace a global variable
|
|
*
|
|
* @return FFI
|
|
*/
|
|
function get_ffi(): FFI
|
|
{
|
|
static $ffi;
|
|
|
|
if ($ffi === NULL)
|
|
{
|
|
$ffi = FFI::load(__DIR__ . '/ffi.h');
|
|
}
|
|
|
|
return $ffi;
|
|
}
|
|
|
|
/**
|
|
* Does the one-character string contain a character that separates tokens?
|
|
*
|
|
* @param string $char
|
|
* @return bool
|
|
*/
|
|
function is_separator(string $char): bool
|
|
{
|
|
if ( ! is_ascii($char))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// `strpos` is used instead of `strchr`/`strstr` as we don't care about the actual match
|
|
// while `strchr` would match the C version, it also returns the match
|
|
$isSep = (strpos(',.()+-/*=~%<>[];', $char) !== FALSE);
|
|
|
|
return is_space($char) || $char === "\0" || $isSep;
|
|
}
|
|
|
|
/**
|
|
* Pull input from the stdin stream.
|
|
*
|
|
* @param int $len
|
|
* @return string
|
|
*/
|
|
function read_stdin(int $len = 128): string
|
|
{
|
|
$handle = fopen('php://stdin', 'rb');
|
|
$input = fread($handle, $len);
|
|
fclose($handle);
|
|
|
|
return $input;
|
|
}
|
|
|
|
/**
|
|
* Write to the stdout stream
|
|
*
|
|
* @param string $str
|
|
* @param int|NULL $len
|
|
* @return int
|
|
*/
|
|
function write_stdout(string $str, int $len = NULL): int
|
|
{
|
|
$handle = fopen('php://stdout', 'ab');
|
|
$res = (is_int($len))
|
|
? fwrite($handle, $str, $len)
|
|
: fwrite($handle, $str);
|
|
|
|
fclose($handle);
|
|
|
|
return $res;
|
|
}
|
|
|
|
function read_stdout(int $len = 128): string
|
|
{
|
|
$handle = fopen('php://stdout', 'rb');
|
|
$input = fread($handle, $len);
|
|
|
|
$input = rtrim($input);
|
|
fclose($handle);
|
|
|
|
return $input;
|
|
}
|
|
|
|
/**
|
|
* Replaces a slice of an array with the same value
|
|
*
|
|
* @param array $array The array to update
|
|
* @param int $offset The index of the first location to update
|
|
* @param int $length The number of indices to update
|
|
* @param mixed $value The value to replace in the range
|
|
*/
|
|
function array_replace_range(array &$array, int $offset, int $length, $value):void
|
|
{
|
|
if ($length === 1)
|
|
{
|
|
$array[$offset] = $value;
|
|
return;
|
|
}
|
|
|
|
$replacement = array_fill(0, $length, $value);
|
|
array_splice($array, $offset, $length, $replacement);
|
|
|
|
/* $end = $offset + $length;
|
|
for ($i = $offset; $i < $end; $i++)
|
|
{
|
|
$array[$i] = $value;
|
|
} */
|
|
}
|
|
|
|
/**
|
|
* Get the ASCII color escape number for the specified syntax type
|
|
*
|
|
* @param int $hl
|
|
* @return int
|
|
*/
|
|
function syntax_to_color(int $hl): int
|
|
{
|
|
$map = [
|
|
Highlight::COMMENT => Color::FG_CYAN,
|
|
Highlight::ML_COMMENT => Color::FG_BRIGHT_BLACK,
|
|
Highlight::KEYWORD1 => Color::FG_YELLOW,
|
|
Highlight::KEYWORD2 => Color::FG_GREEN,
|
|
Highlight::STRING => Color::FG_MAGENTA,
|
|
Highlight::NUMBER => Color::FG_RED,
|
|
Highlight::OPERATOR => Color::FG_BRIGHT_GREEN,
|
|
Highlight::VARIABLE => Color::FG_BRIGHT_CYAN,
|
|
Highlight::DELIMITER => Color::FG_BLUE,
|
|
Highlight::INVALID => Color::BG_BRIGHT_RED,
|
|
Highlight::MATCH => Color::INVERT,
|
|
];
|
|
|
|
return (array_key_exists($hl, $map))
|
|
? $map[$hl]
|
|
: Color::FG_WHITE;
|
|
}
|
|
|
|
/**
|
|
* Replace tabs with the specified number of spaces.
|
|
*
|
|
* @param string $str
|
|
* @param int? $number
|
|
* @return string
|
|
*/
|
|
function tabs_to_spaces(string $str, ?int $number = KILO_TAB_STOP): string
|
|
{
|
|
return str_replace("\t", str_repeat(' ', $number), $str);
|
|
}
|
|
|
|
/**
|
|
* Use 'token_get_all' to get the tokens for a file,
|
|
* organized by row number
|
|
*
|
|
* @param string $code
|
|
* @return array
|
|
*/
|
|
function get_php_tokens(string $code): array
|
|
{
|
|
$rawTokens = token_get_all($code);
|
|
$tokens = [];
|
|
$lineNum = 1;
|
|
$line = [];
|
|
foreach($rawTokens as $t)
|
|
{
|
|
// Simple characters, usually delimiters or single character operators
|
|
if ( ! is_array($t))
|
|
{
|
|
$line[] = [
|
|
'type' => -1,
|
|
'typeName' => 'RAW',
|
|
'char' => tabs_to_spaces($t),
|
|
];
|
|
continue;
|
|
}
|
|
|
|
[$type, $rawChar, $currentLine] = $t;
|
|
$char = tabs_to_spaces($rawChar);
|
|
|
|
$current = [
|
|
'type' => $type,
|
|
'typeName' => token_name($type),
|
|
'char' => $char,
|
|
'line' => $currentLine,
|
|
];
|
|
|
|
if ($char === "\n")
|
|
{
|
|
$line[] = $current;
|
|
$tokens[$lineNum] = $line;
|
|
$lineNum++;
|
|
$line = [];
|
|
}
|
|
|
|
// Only return the first line of a multi-line token for this line array
|
|
if ($char !== "\n" && strpos($char, "\n") !== FALSE)
|
|
{
|
|
$chars = explode("\n", $char);
|
|
$current['original'] = [
|
|
'string' => $char,
|
|
'lines' => $chars,
|
|
];
|
|
$current['char'] = array_shift($chars);
|
|
|
|
// Add new lines for additional newline characters
|
|
$nextLine = $currentLine;
|
|
foreach ($chars as $char)
|
|
{
|
|
$nextLine++;
|
|
|
|
if ( ! array_key_exists($nextLine, $tokens))
|
|
{
|
|
$tokens[$nextLine] = [];
|
|
}
|
|
|
|
$tokens[$nextLine][] = [
|
|
'type' => -1,
|
|
'typeName' => 'RAW',
|
|
'char' => $char,
|
|
];
|
|
}
|
|
}
|
|
|
|
if ($currentLine !== $lineNum)
|
|
{
|
|
$existing = $tokens[$lineNum] ?? [];
|
|
$tokens[$lineNum] = array_merge($existing, $line);
|
|
|
|
$lineNum = $currentLine;
|
|
$line = [];
|
|
}
|
|
|
|
$line[] = $current;
|
|
}
|
|
|
|
$tokens[$lineNum] = array_merge($tokens[$lineNum] ?? [], $line);
|
|
|
|
ksort($tokens);
|
|
|
|
return $tokens;
|
|
}
|
|
|
|
/**
|
|
* Generate/Get the syntax highlighting objects
|
|
*
|
|
* @return array
|
|
*/
|
|
function get_file_syntax_map(): array
|
|
{
|
|
static $db = [];
|
|
|
|
if (count($db) === 0)
|
|
{
|
|
$db = [
|
|
Syntax::new(
|
|
'C',
|
|
['.c', '.h', '.cpp'],
|
|
[
|
|
'continue', 'typedef', 'switch', 'return', 'static', 'while', 'break', 'struct',
|
|
'union', 'class', 'else', 'enum', 'for', 'case', 'if',
|
|
],
|
|
[
|
|
'#include', 'unsigned', '#define', '#ifndef', 'double', 'signed', '#endif',
|
|
'#ifdef', 'float', '#error', '#undef', 'long', 'char', 'int', 'void', '#if',
|
|
],
|
|
'//',
|
|
'/*',
|
|
'*/',
|
|
Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
|
|
),
|
|
Syntax::new(
|
|
'CSS',
|
|
['.css', '.less', '.sass', 'scss'],
|
|
[],
|
|
[],
|
|
'',
|
|
'/*',
|
|
'*/',
|
|
Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
|
|
),
|
|
Syntax::new(
|
|
'JavaScript',
|
|
['.js', '.jsx', '.ts', '.tsx', '.jsm', '.mjs', '.es'],
|
|
[
|
|
'instanceof',
|
|
'continue',
|
|
'debugger',
|
|
'function',
|
|
'default',
|
|
'extends',
|
|
'finally',
|
|
'delete',
|
|
'export',
|
|
'import',
|
|
'return',
|
|
'switch',
|
|
'typeof',
|
|
'break',
|
|
'catch',
|
|
'class',
|
|
'const',
|
|
'super',
|
|
'throw',
|
|
'while',
|
|
'yield',
|
|
'case',
|
|
'else',
|
|
'this',
|
|
'void',
|
|
'with',
|
|
'from',
|
|
'for',
|
|
'new',
|
|
'try',
|
|
'var',
|
|
'do',
|
|
'if',
|
|
'in',
|
|
'as',
|
|
],
|
|
[
|
|
'=>', 'Number', 'String', 'Object', 'Math', 'JSON', 'Boolean',
|
|
],
|
|
'//',
|
|
'/*',
|
|
'*/',
|
|
Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
|
|
),
|
|
Syntax::new(
|
|
'PHP',
|
|
['.php', 'kilo'],
|
|
[
|
|
'?php', '$this', '__halt_compiler', 'abstract', 'and', 'array', 'as', 'break',
|
|
'callable', 'case', 'catch', 'class', 'clone', 'const', 'continue', 'declare',
|
|
'default', 'die', 'do', 'echo', 'else', 'elseif', 'empty', 'enddeclare', 'endfor',
|
|
'endforeach', 'endif', 'endswitch', 'endwhile', 'eval', 'exit', 'extends',
|
|
'final', 'finally', 'for', 'foreach', 'function', 'global', 'goto', 'if', 'implements',
|
|
'include', 'include_once', 'instanceof', 'insteadof', 'interface', 'isset', 'list',
|
|
'namespace', 'new', 'or', 'print', 'private', 'protected', 'public', 'require', 'require_once',
|
|
'return', 'static', 'switch', 'throw', 'trait', 'try', 'unset', 'use', 'var', 'while', 'xor',
|
|
'yield', 'yield from', '__CLASS__', '__DIR__', '__FILE__', '__FUNCTION__', '__LINE__',
|
|
'__METHOD__', '__NAMESPACE__', '__TRAIT__',
|
|
],
|
|
[
|
|
'int', 'float', 'bool', 'string', 'true', 'TRUE', 'false', 'FALSE', 'null', 'NULL',
|
|
'void', 'iterable', 'object', 'strict_types'
|
|
],
|
|
'//',
|
|
'/*',
|
|
'*/',
|
|
Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
|
|
),
|
|
Syntax::new(
|
|
'Rust',
|
|
['.rs'],
|
|
[
|
|
'continue', 'return', 'static', 'struct', 'unsafe', 'break', 'const', 'crate',
|
|
'extern', 'match', 'super', 'trait', 'where', 'else', 'enum', 'false', 'impl',
|
|
'loop', 'move', 'self', 'type', 'while', 'for', 'let', 'mod', 'pub', 'ref', 'true',
|
|
'use', 'mut', 'as', 'fn', 'if', 'in',
|
|
],
|
|
[
|
|
'DoubleEndedIterator',
|
|
'ExactSizeIterator',
|
|
'IntoIterator',
|
|
'PartialOrd',
|
|
'PartialEq',
|
|
'Iterator',
|
|
'ToString',
|
|
'Default',
|
|
'ToOwned',
|
|
'Extend',
|
|
'FnOnce',
|
|
'Option',
|
|
'String',
|
|
'AsMut',
|
|
'AsRef',
|
|
'Clone',
|
|
'Debug',
|
|
'FnMut',
|
|
'Sized',
|
|
'Unpin',
|
|
'array',
|
|
'isize',
|
|
'usize',
|
|
'&str',
|
|
'Copy',
|
|
'Drop',
|
|
'From',
|
|
'Into',
|
|
'None',
|
|
'Self',
|
|
'Send',
|
|
'Some',
|
|
'Sync',
|
|
'Sync',
|
|
'bool',
|
|
'char',
|
|
'i128',
|
|
'u128',
|
|
'Box',
|
|
'Err',
|
|
'Ord',
|
|
'Vec',
|
|
'dyn',
|
|
'f32',
|
|
'f64',
|
|
'i16',
|
|
'i32',
|
|
'i64',
|
|
'str',
|
|
'u16',
|
|
'u32',
|
|
'u64',
|
|
'Eq',
|
|
'Fn',
|
|
'Ok',
|
|
'i8',
|
|
'u8',
|
|
],
|
|
'//',
|
|
'/*',
|
|
'*/',
|
|
Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
|
|
),
|
|
];
|
|
}
|
|
|
|
return $db;
|
|
}
|