Keskustelu: Koodit: PHP: Koodin väritys (C++-koodille)

<?php # cpp.php

/**
 * Funktio muuttaa C- tai C++-koodin HTML-muotoon.
 *
 * Koodista tunnistettavat elementit ovat seuraavat:
 *   - kommentit (CSS: .comment)
 *   - teksti (CSS: .string)
 *   - merkit (CS: .char)
 *   - luvut (CSS: .number)
 *   - esikääntäjän komennot (CSS: .preprocessor)
 *   - tyhjä (CSS: .whitespace)
 *   - avainsanat (CSS: .reserved)
 *   - operaattorit (CSS: .operator)
 *   - operaattorisanat (CSS: .operator_word)
 *   - nimet (CSS: .identifier)
 * Näistä nimet, operaattorit ja tyhjä jätetään oletusarvoisesti värittämättä.
 * (ks. funktio html_cpp_format)
 *
 * Koodista on kommentoitu pois pari vaihtoehtoista osumatapaa.
 *
 * @param string $str Muunnettava koodi.
 * @return string Paluuarvona on muunnettu koodi.
 */
function html_cpp($str) {
	# Säännöllinen lauseke rivinvaihdolle:
	$nl = $new_line = "(?>\r\n|\r|\n)";
	# Vastaava look-ahead, joka ei ota merkkejä mukaan osumaan:
	$lanl = $look_ahead_new_line = "(?={$nl})";
	# Käänteinen versio edellisestä.
	$lannl = $look_ahead_no_new_line = "(?!{$nl})";
	# Jos rivi loppuu \-merkkiin, esikääntäjä yhdistää sen seuraavaan.
	# Tehdään lauseke tämän tunnistamiseen.
	$pnl = $preprocessor_new_line = "(?>\\\\{$nl})*";

	# Muodostetaan lausekkeet eri tilanteisiin:
	$comment1 = "(?>/{$pnl}/{$pnl}(?:.*?{$pnl})*?{$lanl})";
	$comment2 = "(?>/{$pnl}\\*(?:.*?{$nl}?)*?\\*{$pnl}/)";
	$comment = "(?>$comment1|$comment2)";
	$string = "(?>(?>L{$pnl})?\"(?>[^\\\\\"]*(?>\\\\{$pnl}{$lannl}.)*{$pnl})*\"{$pnl})";
	$char = "(?>(?>L{$pnl})?'(?>{$pnl}(?>[^\\\\']|(?>\\\\{$pnl}{$lannl}.))+{$pnl})+'{$pnl})";
	$word = "(?>[A-Za-z_]{$pnl}(?>[A-Za-z0-9_]+{$pnl})*)";
	$number = "(?>(?>\\.{$pnl})?[0-9](?>(?>(?>[eEpP]{$pnl}[-+])|[A-Za-z0-9_.])*{$pnl})*)";
	$whitespace = "(?>(?>(?>[ \t\f\v]+{$pnl})+{$nl}?)|{$nl})";
	# Tämä ottaisi esikääntäjän komennon loppuun asti:
	#$preprocessor = "(?:^(?:[ \t\f\v]+{$pnl})*#(?:.*?{$pnl})*{$lanl})";
	# Tämä ottaisi sen vain komentosanan loppuun:
	#$preprocessor = "(?:^(?:[ \t\f\v]+{$pnl})*#(?:[ \t\f\v]*{$pnl})*(?:[A-Za-z0-9_]*{$pnl})*)";
	# Tämä ottaa lisäksi tavallisen includen tiedostonimen hakasuluista:
	$preprocessor = "(?>^(?>[ \t\f\v]+{$pnl})*#(?>[ \t\f\v]*{$pnl})*(?>(?>include[ \t]*\\<[^>]+\\>)|(?>[A-Za-z0-9_]*{$pnl})*))";
	$operator = html_cpp_operator_regex($pnl);
	# Muut kuin esiintyneet merkit ovat virheellisiä,
	# ja virheeksi kelpaa myös yksi mikä tahansa merkki,
	# jos sitä ei ole tunnistettu aiemmin.
	# Lisäksi tunnistetaan tyhjä '' virheeksi, jolloin
	# lausekkeesta '' + 'b' värittyy '' virheeksi ja 'b' merkiksi.
	$chars_ok = "\\-A-Za-z0-9_" . preg_quote("!#%&()*+,./:;<=>?[]^{|}~\"' \t\f\v\r\n");
	$error = "(?>'{$pnl}'|(?>[^$chars_ok](?>[^$chars_ok]*{$pnl})*)|.)";

	# Kootaan lausekkeet taulukkoon.
	# Järjestys on tärkeä, jottei aiempi lauseke voi osua sellaiseen,
	# johon kuuluisi myöhempi, esim. operaattori # esikääntäjän riveissä.
	$regex_arr = compact(
		"string", "char", "word", "comment", "preprocessor",
		"whitespace", "number", "operator", "error"
	);

	# Muutetaan lausekkeet nimetyiksi ryhmiksi ja yhdistetään.
	$named = array();
	foreach ($regex_arr as $name => $exp) {
		$named[] = "(?P<$name>$exp{$pnl})";
	}
	$regex = sprintf("`(%s)`m", implode("|", $named));

	# Haetaan osumat ja käsitellään ne html_cpp_match-funktiolla.
	$res = preg_replace_callback($regex, "html_cpp_match", $str);

	# Jos korvaus menee pieleen, palautetaan väritön, HTML-muotoinen koodi.
	if (empty($res)) {
		$res = htmlspecialchars($str);
	}
	return "<pre class='cpp'><code>$res</code></pre>";
}

/**
 * Funktiota käytetään preg_replace_callback-funktion callback-parametrina.
 * Se muuttaa löytyneen C++-pätkän HTML-muotoon.
 *
 * @param array $match Osuman tiedot taulukkona preg_replace_callback-funktiota.
 * @return string Paluuarvona on HTML-muotoinen esitys osumasta.
 */
function html_cpp_match($match) {
	# Haetaan osumasta viimeinen nimetty ryhmä ja muotoillaan se.
	# Käydään siis taulukkoa lopusta alkuun, kunnes löytyy
	# tekstillä nimetty ryhmä.
	end($match);
	while (!is_string(key($match))) {
		prev($match);
	}
	$type = key($match);
	$str = current($match);
	return html_cpp_format($type, $str);
}

/**
 * Funktio palauttaa säännöllisen lausekkeen osan, joka tunnistaa operaattorit.
 *
 * @param string $pnl esikääntäjän rivinvaihdon tunnistus
 * @return string Paluuarvona säännöllisen lausekkeen osa.
 */
function html_cpp_operator_regex($pnl = "") {
	# Säilötään vastausta ja palautetaan vanha, jos on jo koottu se.
	static $operator;
	if (!empty($operator)) {
		return $operator;
	}
	# Lista operaattoreista on järjestetty niin, että pisimmät kokeillaan
	# ensin, jottei <<:sta tulisi vahingossa kahta erillistä <:ta.
	/*
	$operators = array(
		'~', '}', '||', '|=', '|', '{', '^=', '^', ']', '[', '?', '>>=',
		'>>', '>=', '>', '==', '=', '<=', '<<=', '<<', '<:', '<%', '<',
		';', ':>', '::', ':', '/=', '/', '...', '.*', '.', '->*', '->',
		'-=', '--', '-', ',', '+=', '++', '+', '*=', '*', ')', '(',
		'&=', '&&', '&', '%>', '%=', '%:%:', '%:', '%', '##', '#', '!=',
		'!'
	);
	*/
	# Valmiiksi muotoillut säännölliset lausekkeet helpottavat tilannetta.
	# Kaikkiin väleihin on taas lisätty esikääntäjän rivinvaihdot.
	$operators = array(
		# nelimerkkiset
		"(?>%{$pnl}\\:{$pnl}%{$pnl}\\:)",
		# >>=? <<=?
		"(?>(?>(?>\\<{$pnl}\\<)|(?>\\>{$pnl}\\>)){$pnl}\\=?)",
		# ->*?
		"(?>-{$pnl}\\>{$pnl}\\*?)",
		# toistot, &&, ...
		"(?:\\|{$pnl}\\|)|(?:\\:{$pnl}\\:)|(?:\\.{$pnl}\\.{$pnl}\\.)",
		"(?:\\-{$pnl}\\-)|(?:\\+{$pnl}\\+)|(?:&{$pnl}&)|(?:#{$pnl}#)",
		# kaksimerkkiset, .=
		"(?:[|^>=</\\-*&%!]{$pnl}\\=)",
		# muut kaksimerkkiset
		"(?:\\<{$pnl}[:%])|(?:[:%]{$pnl}\\>)|(?:\\.{$pnl}\\*)|(?:%{$pnl}\\:)",
		# yksimerkkiset
		"[~}|{^\\]\\[?>=<;:/.\\-,+*)(&%#!]",
	);
	$operator = sprintf("(?>(?>%s){$pnl})", implode("|", $operators));
	return $operator;
}

/**
 * Funktio selvittää löytyneen sanan tyypin (varattu sana, nimi, operaattori).
 *
 * @param string $str Sana.
 * @return string Paluuarvona on sanan tyyppi.
 */
function html_cpp_word_type(&$str) {
	# Listat C++:n varatuista sanoista ja operaattorisanoista;
	# staattisuudella optimoidaan koodia, kun taulukkoa ei luoda joka kerta,
	# ja siirtämällä sanat taulukon avaimiksi nopeutetaan sanan etsimistä.
	static $cpp_reserved_words, $cpp_operator_words;
	if (empty($cpp_reserved_words)) {
		$cpp_reserved_words = array(
			'asm', 'auto', 'bool', 'break', 'case', 'catch', 'char',
			'class', 'const', 'const_cast', 'continue', 'default', 'do',
			'double', 'dynamic_cast', 'else', 'enum', 'explicit', 'export',
			'extern', 'false', 'float', 'for', 'friend', 'goto', 'if',
			'inline', 'int', 'long', 'mutable', 'namespace', 'operator',
			'private', 'protected', 'public', 'register',
			'reinterpret_cast', 'return', 'short', 'signed', 'sizeof',
			'static', 'static_cast', 'struct', 'switch', 'template', 'this',
			'throw', 'true', 'try', 'typedef', 'typeid', 'typename',
			'union', 'unsigned', 'using', 'virtual', 'void', 'volatile',
			'while', 'wchar_t',
		);
		$cpp_operator_words = array(
			'new', 'delete',
			'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not', 'not_eq',
			'or', 'or_eq', 'xor', 'xor_eq',
		);
		$cpp_reserved_words = array_flip($cpp_reserved_words);
		$cpp_operator_words = array_flip($cpp_operator_words);
	}
	# Poistetaan esikääntäjän rivinvaihdot, jotta sana tunnistetaan oikein.
	$word = preg_replace("/[^A-Za-z0-9_]/s", "", $str);

	# Katsotaan, mistä listasta sana löytyy.
	if (isset($cpp_reserved_words[$word])) {
		return "reserved";
	} elseif (isset($cpp_operator_words[$word])) {
		return "operator_word";
	} else {
		# Tuntemattomat sanat ovat nimiä.
		return "identifier";
	}
}

/**
 * Funktio muuttaa löytyneen C++-pätkän HTML-muotoon.
 *
 * @param string $type Osuman tyyppi (comment, string, char etc.)
 * @param string $str Osuman teksti.
 * @return string Paluuarvona on HTML-muotoinen esitys osumasta.
 */
function html_cpp_format(&$type, &$str) {
	# Jos löytyi tarkemmin määrittelemätön sana, tarkistetaan,
	# onko se ehkä varattu sana tai operaattori.
	if ($type == "word") {
		$type = html_cpp_word_type($str);
	}

	# Luodaan osuman HTML-esitys (erikoismerkit HTML-muodossa)
	$html = htmlspecialchars($str);

	# Jätetään satunnaiset nimet, operaattorit ja tyhjä värittämättä.
	# Nämäkin voi tietysti värittää, jos haluaa.
	$ignore = array("identifier", "operator", "whitespace");
	if (in_array($type, $ignore)) {
		return $html;
	}
	# Väreihin käytetään CSS-luokkia, jotta väritystä on helppo muuttaa.
	return "<span class='{$type}'>{$html}</span>";
}
?>

/* cpp.css */
/* pre ja code ovat koko koodin ympärillä;
 * asetetaan reunat ja tarvittaessa vierityspalkki */
pre.cpp {
	display: block;
	border: 1px solid black;
	margin: 2px;
	padding: 2px;
	background-color: white;
	width: 99%;
	overflow: auto;
}
.cpp code {
	color: black;
}
/* nämä jätettiin PHP:ssä värjäämättä mutta nekin voisi:
.cpp .identifier, .cpp .operator, .cpp .whitespace {
	color: black;
}
*/
.cpp .comment {
	color: green;
}
.cpp .preprocessor {
	color: teal;
}
.cpp .reserved, .cpp .operator_word {
	color: navy;
	font-weight: bold;
}
.cpp .string {
	color: maroon;
}
.cpp .char, .cpp .number {
	color: blue;
}
.cpp .error {
	color: red;
}

/* DEBUG: piirretään laatikko joka ryhmän ympärille
.cpp span {
	border: 1px solid green;
}
*/

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fi" lang="fi">
<head>
	<meta http-equiv="Content-Type" content="application/xhtml+xml; charset=utf-8" />
	<meta http-equiv="Content-Language" content="fi" />
	<title>C++-väritysesimerkki</title>
	<style type="text/css" media="all">@import "cpp.css";</style>
	<!--[if IE]>
		<style type="text/css" media="all">@import "cpp-ie.css";</style>
	<![endif]-->
</head>
<body>
<?php
require_once("cpp.php");
$koodi = file_get_contents("esim.cpp");
echo html_cpp($koodi);
?>
</body>
</html>

#include <iostream>
#if 0
	#include "omaotsikko.hpp"
#elif 0
	#	error "moi"
#endif

#defi\
ne F(x) \
int x %:%\
: _muuttuja

F(moi);

using namespace std;

class X {
public:
	X& operator ++(int) { return *this; }
	X& operator ++() { return *this; }
};

type\
def float taulu[3];

int main(int argc, char **argv) {
	taulu t;
	t[0] = 0x12ul;
	t[1] = 0377LU;
	t[2] = 1.12e-6L + 1e3f + 2. + .6;
	X x, y = x++++;
	std::cout
		<< "t[2] (float) == \"" << t[2] << "\"\\" << std::endl // << kommentti;
		// kommentteja pitäisi voida \
		   jatkaa monelle riville
		<< "char c = " << '\'' << (int) L'x' << '\'' << std::endl;
	std::cout <<
"Tekstikin voi olla \
\
monta riviä pitkä.\n";
/*
 * Tästäpä ei mikä tahansa viritys selviä: *\
/
std::cout <<
"Myös escape voi jakautua monelle riville: \\
n jee \\
", samoin luvut: " << 12.\
34e-\
1l << std::endl;
// */
	return 0;
}