Skip to content
Extraits de code Groupes Projets

Comparer les révisions

Les modifications sont affichées comme si la révision source était fusionnée avec la révision cible. En savoir plus sur la comparaison des révisions.

Source

Sélectionner le projet cible
No results found

Cible

Sélectionner le projet cible
  • spip/spip
  • Roman/spip
  • g0uZ/spip_puce_changement_statut_rapide_sans_JS_inline
  • erational/issue_4450
  • cy.altern/spip_core
  • fa_b/spip
  • glopglop/spip
  • MathieuAlphamosa/spip
  • taffit/spip
  • claffont/spip
  • RealET/spip
  • alexis.pellicier/spip
  • syl20/spip
  • cpol/spip_cpol0
  • franck_r/spip
  • JLuc/spip
  • JLuc/jluc-spip
  • bricebou/spip
  • Jack31/spip-issue-5919
  • Plumf/spip
  • jo/spip
  • pierretux/spip
  • placido/spip
  • touti/spip
  • florent.tri/spip
25 résultats
Afficher les modifications
Affichage de
avec 0 ajout et 3751 suppressions
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
include_spip('inc/acces');
include_spip('base/serial');
include_spip('base/auxiliaires');
include_spip('base/typedoc');
include_spip('base/abstract_sql');
// http://doc.spip.org/@creer_ou_upgrader_table
function creer_ou_upgrader_table($table,$desc,$autoinc,$upgrade=false,$serveur='') {
global $tables_principales;
$sql_desc = sql_showtable($table,true,$serveur);
if (!$upgrade OR !$sql_desc) {
if ($autoinc==='auto') {
if (isset($tables_principales[$table]))
$autoinc = true;
elseif (isset($tables_principales[$table]))
$autoinc = false;
else {
// essayer de faire au mieux !
$autoinc = (isset($desc['key']['PRIMARY KEY'])
AND strpos($desc['key']['PRIMARY KEY'],',')===false
AND strpos($desc['field'][$desc['key']['PRIMARY KEY']],'default')===false);
}
}
sql_create($table, $desc['field'], $desc['key'], $autoinc, false, $serveur);
}
else {
// ajouter les champs manquants
$last = '';
foreach($desc['field'] as $field=>$type){
if (!isset($sql_desc['field'][$field]))
sql_alter("TABLE $table ADD $field $type".($last?" AFTER $last":""),$serveur);
$last = $field;
}
}
}
// http://doc.spip.org/@creer_base
function creer_base($serveur='') {
global $tables_principales, $tables_auxiliaires;
// Note: les mises a jour reexecutent ce code pour s'assurer
// de la conformite de la base
// pas de panique sur "already exists" et "duplicate entry" donc.
foreach($tables_principales as $k => $v)
creer_ou_upgrader_table($k,$v,true,false,$serveur);
foreach($tables_auxiliaires as $k => $v)
creer_ou_upgrader_table($k,$v,false,false,$serveur);
}
// http://doc.spip.org/@maj_tables
function maj_tables($upgrade_tables=array(),$serveur=''){
global $tables_principales, $tables_auxiliaires;
foreach($tables_principales as $k => $v)
if (($upgrade_tables==$k OR (is_array($upgrade_tables) && in_array($k,$upgrade_tables))))
creer_ou_upgrader_table($k,$v,true,true,$serveur);
foreach($tables_auxiliaires as $k => $v)
if (($upgrade_tables==$k OR (is_array($upgrade_tables) && in_array($k,$upgrade_tables))))
creer_ou_upgrader_table($k,$v,false,true,$serveur);
}
// http://doc.spip.org/@creer_base_types_doc
function creer_base_types_doc($serveur='') {
global $tables_images, $tables_sequences, $tables_documents, $tables_mime;
foreach ($tables_mime as $extension => $type_mime) {
if (isset($tables_images[$extension])) {
$titre = $tables_images[$extension];
$inclus='image';
}
else if (isset($tables_sequences[$extension])) {
$titre = $tables_sequences[$extension];
$inclus='embed';
}
else {
$inclus='non';
if (isset($tables_documents[$extension]))
$titre = $tables_documents[$extension];
else
$titre = '';
}
// Init ou Re-init ==> replace pas insert
sql_replace('spip_types_documents',
array('mime_type' => $type_mime,
'titre' => $titre,
'inclus' => $inclus,
'extension' => $extension,
'upload' => 'oui'
),
'', $serveur);
}
}
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// http://doc.spip.org/@base_delete_all_dist
function base_delete_all_dist($titre)
{
$delete = _request('delete');
$res = array();
if (is_array($delete)) {
foreach ($delete as $table) {
if (sql_drop_table($table))
$res[] = $table;
else spip_log("SPIP n'a pas pu detruire $table.");
}
// un pipeline pour detruire les tables installees par les plugins
pipeline('delete_tables', '');
spip_unlink(_FILE_CONNECT);
spip_unlink(_FILE_CHMOD);
spip_unlink(_FILE_META);
spip_unlink(_ACCESS_FILE_NAME);
spip_unlink(_CACHE_RUBRIQUES);
}
$d = count($delete);
$r = count($res);
spip_log("Tables detruites: $r sur $d: " . join(', ',$res));
}
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
define('_VERSION_ARCHIVE', '1.3');
include_spip('base/serial');
include_spip('base/auxiliaires');
include_spip('public/interfaces'); // pour table_jointures
// NB: Ce fichier peut ajouter des tables (old-style)
// donc il faut l'inclure "en globals"
if ($f = find_in_path('mes_fonctions.php')) {
global $dossier_squelettes;
@include_once (_ROOT_CWD . $f);
}
if (@is_readable(_CACHE_PLUGINS_FCT)){
// chargement optimise precompile
include_once(_CACHE_PLUGINS_FCT);
}
function base_dump_meta_name($rub){
return $meta = "status_dump_$rub_" . $GLOBALS['visiteur_session']['id_auteur'];
}
function base_dump_dir($meta){
// determine upload va aussi initialiser l'index "restreint"
$maindir = determine_upload();
if (!$GLOBALS['visiteur_session']['restreint'])
$maindir = _DIR_DUMP;
$dir = sous_repertoire($maindir, $meta);
return $dir;
}
/**
* Lister toutes les tables d'un serveur
* en excluant eventuellement une liste fournie
*
* @param string $serveur
* @param array $tables
* @param array $exclude
* @return array
*/
function base_lister_toutes_tables($serveur='', $tables=array(), $exclude = array()) {
spip_connect($serveur);
$connexion = $GLOBALS['connexions'][$serveur ? $serveur : 0];
$prefixe = $connexion['prefixe'];
$p = '/^' . $prefixe . '/';
$res = $tables;
foreach(sql_alltable(null,$serveur) as $t) {
if (preg_match($p, $t)) {
$t = preg_replace($p, 'spip', $t);
if (!in_array($t, $tables) AND !in_array($t, $exclude)) $res[]= $t;
}
}
sort($res);
return $res;
}
/**
* Fabrique la liste a cocher des tables a traiter (copie, delete, sauvegarde)
*
* @param string $name
* @param bool $check
* @return string
*/
function base_saisie_tables($name, $tables, $exclude = array(), $post=null, $serveur='') {
include_spip('inc/filtres');
foreach ($tables as $k => $t) {
// par defaut tout est coche sauf les tables dans $exclude
if (is_null($post))
$check = (in_array($t,$exclude)?false:true);
// mais si on a poste une selection, la reprendre
else
$check = in_array($t,$post);
$res[$k] = "<input type='checkbox' value='$t' name='$name"
. "[]' id='$name$k'"
. ($check ? " checked='checked'" : '')
. "/>\n"
. "<label for='$name$k'>".$t."</label>"
. " ("
. sinon(singulier_ou_pluriel(sql_countsel($t,'','','',$serveur), 'dump:une_donnee', 'dump:nb_donnees'),_T('dump:aucune_donnee'))
. ")";
}
return $res;
}
/**
* Lister les tables non exportables par defaut
* (liste completable par le pipeline lister_tables_noexport
*
* @staticvar array $EXPORT_tables_noexport
* @return array
*/
function lister_tables_noexport(){
// par defaut tout est exporte sauf les tables ci-dessous
static $EXPORT_tables_noexport = null;
if (!is_null($EXPORT_tables_noexport))
return $EXPORT_tables_noexport;
$EXPORT_tables_noexport= array(
'spip_caches', // plugin invalideur
'spip_resultats', // resultats de recherche ... c'est un cache !
'spip_test', // c'est un test !
#'spip_referers',
#'spip_referers_articles',
#'spip_visites',
#'spip_visites_articles',
#'spip_versions',
#'spip_versions_fragments'
);
if (!$GLOBALS['connect_toutes_rubriques']){
$EXPORT_tables_noexport[]='spip_messages';
#$EXPORT_tables_noexport[]='spip_auteurs_liens'; // where objet='message'
}
$EXPORT_tables_noexport = pipeline('lister_tables_noexport',$EXPORT_tables_noexport);
return $EXPORT_tables_noexport;
}
/**
* Lister les tables non importables par defaut
* (liste completable par le pipeline lister_tables_noexport
*
* @staticvar array $IMPORT_tables_noimport
* @return array
*/
function lister_tables_noimport(){
static $IMPORT_tables_noimport=null;
if (!is_null($EXPORT_tables_noexport))
return $EXPORT_tables_noexport;
$IMPORT_tables_noimport = array();
// par defaut tout est importe sauf les tables ci-dessous
// possibiliter de definir cela tables via la meta
// compatibilite
if (isset($GLOBALS['meta']['IMPORT_tables_noimport'])){
$IMPORT_tables_noimport = unserialize($GLOBALS['meta']['IMPORT_tables_noimport']);
if (!is_array($IMPORT_tables_noimport)){
include_spip('inc/meta');
effacer_meta('IMPORT_tables_noimport');
}
}
$IMPORT_tables_noimport = pipeline('lister_tables_noimport',$IMPORT_tables_noimport);
return $IMPORT_tables_noimport;
}
/**
* Lister les tables a ne pas effacer
* (liste completable par le pipeline lister_tables_noerase
*
* @staticvar array $IMPORT_tables_noerase
* @return array
*/
function lister_tables_noerase(){
static $IMPORT_tables_noerase=null;
if (!is_null($IMPORT_tables_noerase))
return $IMPORT_tables_noerase;
$IMPORT_tables_noerase = array(
'spip_meta',
// par defaut on ne vide pas les stats, car elles ne figurent pas dans les dump
// et le cas echeant, un bouton dans l'admin permet de les vider a la main...
'spip_referers',
'spip_referers_articles',
'spip_visites',
'spip_visites_articles'
);
$IMPORT_tables_noerase = pipeline('lister_tables_noerase',$IMPORT_tables_noerase);
return $IMPORT_tables_noerase;
}
/**
* construction de la liste des tables pour le dump :
* toutes les tables principales
* + toutes les tables auxiliaires hors relations
* + les tables relations dont les deux tables liees sont dans la liste
*
* @global <type> $tables_principales
* @global <type> $tables_auxiliaires
* @global <type> $tables_jointures
* @param array $exclude_tables
* @return array
*/
function base_liste_table_for_dump($exclude_tables = array()){
$tables_for_dump = array();
$tables_pointees = array();
global $tables_principales;
global $tables_auxiliaires;
global $tables_jointures;
// on construit un index des tables de liens
// pour les ajouter SI les deux tables qu'ils connectent sont sauvegardees
$tables_for_link = array();
foreach($tables_jointures as $table => $liste_relations)
if (is_array($liste_relations))
{
$nom = $table;
if (!isset($tables_auxiliaires[$nom])&&!isset($tables_principales[$nom]))
$nom = "spip_$table";
if (isset($tables_auxiliaires[$nom])||isset($tables_principales[$nom])){
foreach($liste_relations as $link_table){
if (isset($tables_auxiliaires[$link_table])/*||isset($tables_principales[$link_table])*/){
$tables_for_link[$link_table][] = $nom;
}
else if (isset($tables_auxiliaires["spip_$link_table"])/*||isset($tables_principales["spip_$link_table"])*/){
$tables_for_link["spip_$link_table"][] = $nom;
}
}
}
}
$liste_tables = array_merge(array_keys($tables_principales),array_keys($tables_auxiliaires));
foreach($liste_tables as $table){
// $name = preg_replace("{^spip_}","",$table);
if ( !isset($tables_pointees[$table])
&& !in_array($table,$exclude_tables)
&& !isset($tables_for_link[$table])){
$tables_for_dump[] = $table;
$tables_pointees[$table] = 1;
}
}
foreach ($tables_for_link as $link_table =>$liste){
$connecte = true;
foreach($liste as $connect_table)
if (!in_array($connect_table,$tables_for_dump))
$connecte = false;
if ($connecte)
# on ajoute les liaisons en premier
# si une restauration est interrompue,
# cela se verra mieux si il manque des objets
# que des liens
array_unshift($tables_for_dump,$link_table);
}
return array($tables_for_dump, $tables_for_link);
}
/**
* Vider les tables de la base de destination
* pour la copie dans une base
*
* peut etre utilise pour l'import depuis xml,
* ou la copie de base a base (mysql<->sqlite par exemple)
*
* @param array $tables
* @param string $serveur
*/
function base_vider_tables_destination_copie($tables, $exlure_tables = array(), $serveur=''){
$trouver_table = charger_fonction('trouver_table', 'base');
spip_log('Vider '.count($tables) . " tables sur serveur '$serveur' : " . join(', ', $tables),'base');
foreach($tables as $table){
// sur le serveur principal, il ne faut pas supprimer l'auteur loge !
if (($table!='spip_auteurs') OR $serveur!=''){
// regarder si il y a au moins un champ impt='non'
$desc = $trouver_table($table);
if (isset($desc['field']['impt']))
sql_delete($table, "impt='oui'", $serveur);
else
sql_delete($table, "", $serveur);
}
}
// sur le serveur principal, il ne faut pas supprimer l'auteur loge !
// Bidouille pour garder l'acces admin actuel pendant toute la restauration
if ($serveur=='') {
spip_log('Conserver copieur '.$GLOBALS['visiteur_statut']['id_auteur'] . " dans id_auteur=0 pour le serveur '$serveur'",'dump');
sql_delete("spip_auteurs", "id_auteur=0",$serveur);
// utiliser le champ webmestre pour stocker l'ancien id ne marchera pas si l'id comporte plus de 3 chiffres...
sql_updateq('spip_auteurs', array('id_auteur'=>0, 'webmestre'=>$GLOBALS['visiteur_statut']['id_auteur']), "id_auteur=".intval($GLOBALS['visiteur_statut']['id_auteur']),array(),$serveur);
sql_delete("spip_auteurs", "id_auteur!=0",$serveur);
}
}
/**
* Effacement de la bidouille ci-dessus
* Toutefois si la table des auteurs ne contient plus qu'elle
* c'est que la copie etait incomplete et on restaure le compte
* pour garder la connection au site
*
* (mais il doit pas etre bien beau
* et ca ne marche que si l'id_auteur est sur moins de 3 chiffres)
*
* @param string $serveur
*/
function base_detruire_copieur_si_besoin($serveur='')
{
// rien a faire si ce n'est pas le serveur principal !
if ($serveur=='') {
if (sql_countsel("spip_auteurs", "id_auteur<>0")) {
spip_log("Detruire copieur id_auteur=0 pour le serveur '$serveur'",'dump');
sql_delete("spip_auteurs", "id_auteur=0", $serveur);
}
else {
spip_log("Restaurer copieur id_auteur=0 pour le serveur '$serveur' (aucun autre auteur en base)",'dump');
sql_update('spip_auteurs', array('id_auteur'=>'webmestre', 'webmestre'=>"'oui'"), "id_auteur=0");
}
}
}
/**
* Preparer la table dans la base de destination :
* la droper si elle existe (sauf si auteurs ou meta sur le serveur principal)
* la creer si necessaire, ou ajouter simplement les champs manquants
*
* @param string $table
* @param array $desc
* @param string $serveur_dest
* @param bool $init
* @return array
*/
function base_preparer_table_dest($table, $desc, $serveur_dest, $init=false) {
$upgrade = false;
// si la table existe et qu'on est a l'init, la dropper
if ($desc_dest=sql_showtable($table,false,$serveur_dest) AND $init) {
if ($serveur_dest=='' AND in_array($table,array('spip_meta','spip_auteurs'))) {
// ne pas dropper auteurs et meta sur le serveur principal
// faire un simple upgrade a la place
// pour ajouter les champs manquants
$upgrade = true;
}
else {
sql_drop_table($table, '', $serveur_dest);
spip_log("drop table '$table' sur serveur '$serveur_dest'",'dump');
}
$desc_dest = false;
}
// si la table n'existe pas dans la destination, la creer a l'identique !
if (!$desc_dest) {
spip_log("creation '$table' sur serveur '$serveur_dest'",'dump');
include_spip('base/create');
creer_ou_upgrader_table($table, $desc, 'auto', $upgrade,$serveur_dest);
$desc_dest = sql_showtable($table,false,$serveur_dest);
}
return $desc_dest;
}
/**
* Copier de base a base
*
* @param string $status_file
* nom avec chemin complet du fichier ou est stocke le status courant
* @param array $tables
* liste des tables a copier
* @param string $serveur_source
* @param string $serveur_dest
* @param array $options
* parametres optionnels sous forme de tableau :
* @param string $callback_progression
* fonction a appeler pour afficher la progression, avec les arguments (compteur,total,table)
* @param int $max_time
* limite de temps au dela de laquelle sortir de la fonction proprement (de la forme time()+15)
* @param bool $drop_source
* vider les tables sources apres copie
* @param array $no_erase_dest
* liste des tables a ne pas vider systematiquement (ne seront videes que si existent dans la base source)
* @param array $where
* liste optionnelle de condition where de selection des donnees pour chaque table
* @param array $fonction_base_inserer
* fonction d'insertion en base. Par defaut "base_inserer_copie" qui fait un insertq a l'identique
* peut etre personalisee pour filtrer, renumeroter....
* @param array $desc_tables_dest
* description des tables de destination a utiliser de preference a la description de la table source
*
* @return <type>
*/
function base_copier_tables($status_file, $tables, $serveur_source, $serveur_dest, $options=array()){
$callback_progression = isset($options['callback_progression'])?$options['callback_progression']:'';
$max_time = isset($options['max_time'])?$options['max_time']:0;
$drop_source = isset($options['drop_source'])?$options['drop_source']:false;
$no_erase_dest = isset($options['no_erase_dest'])?$options['no_erase_dest']:array();
$where = isset($options['where'])?$options['where']:array();
$fonction_base_inserer = isset($options['fonction_base_inserer'])?$options['fonction_base_inserer']:'base_inserer_copie';
$desc_tables_dest = isset($options['desc_tables_dest'])?$options['desc_tables_dest']:array();
spip_log("Copier ".count($tables)." tables de '$serveur_source' vers '$serveur_dest'",'dump');
if (!function_exists($fonction_base_inserer)) {
spip_log("Fonction '$fonction_base_inserer' inconnue. Abandon",'dump');
return true; // echec mais on a fini, donc true
}
if (!lire_fichier($status_file, $status)
OR !$status = unserialize($status))
$status = array();
$status['etape'] = 'copie';
// puis relister les tables a importer
// et les vider si besoin, au moment du premier passage ici
$initialisation_copie = (!isset($status["dump_status_copie"])) ? 0 : $status["dump_status_copie"];
// si init pas encore faite, vider les tables du serveur destination
if (!$initialisation_copie) {
base_vider_tables_destination_copie($tables, $no_erase_dest, $serveur_dest);
$status["dump_status_copie"]='ok';
ecrire_fichier($status_file,serialize($status));
}
spip_log("Tables a copier :".implode(", ",$tables),'dump');
// les tables auteurs et meta doivent etre copiees en dernier !
if (in_array('spip_auteurs',$tables)){
$tables = array_diff($tables,array('spip_auteurs'));
$tables[] = 'spip_auteurs';
}
if (in_array('spip_meta',$tables)){
$tables = array_diff($tables,array('spip_meta'));
$tables[] = 'spip_meta';
}
foreach ($tables as $table){
// verifier que la table est presente dans la base source
if ($desc_source = sql_showtable($table,false,$serveur_source)){
// $status['tables_copiees'][$table] contient l'avancement
// de la copie pour la $table : 0 a N et -N quand elle est finie (-1 si vide et finie...)
if (!isset($status['tables_copiees'][$table]))
$status['tables_copiees'][$table] = 0;
if (is_numeric($status['tables_copiees'][$table])
AND $status['tables_copiees'][$table]>=0
AND $desc_dest = base_preparer_table_dest(
$table,
isset($desc_tables_dest[$table])?$desc_tables_dest[$table]:$desc_source,
$serveur_dest,
$status['tables_copiees'][$table] == 0)){
if ($callback_progression)
$callback_progression($status['tables_copiees'][$table],0,$table);
while (true) {
$n = intval($status['tables_copiees'][$table]);
// on copie par lot de 400
$res = sql_select('*',$table,isset($where[$table])?$where[$table]:'','','',"$n,400",'',$serveur_source);
while ($row = sql_fetch($res,$serveur_source)){
// si l'enregistrement est deja en base, ca fera un echec ou un doublon
$fonction_base_inserer($table,$row,$desc_dest,$serveur_dest);
$status['tables_copiees'][$table]++;
if ($max_time AND time()>$max_time)
break;
}
if ($n == $status['tables_copiees'][$table])
break;
spip_log("recopie $table ".$status['tables_copiees'][$table],'dump');
if ($callback_progression)
$callback_progression($status['tables_copiees'][$table],0,$table);
ecrire_fichier($status_file,serialize($status));
if ($max_time AND time()>$max_time)
return false; // on a pas fini, mais le temps imparti est ecoule
}
if ($drop_source) {
sql_drop_table($table,'',$serveur_source);
spip_log("drop $table sur serveur source '$serveur_source'",'dump');
}
$status['tables_copiees'][$table]=($status['tables_copiees'][$table]?-$status['tables_copiees'][$table]:"zero");
ecrire_fichier($status_file,serialize($status));
spip_log("tables_recopiees ".implode(',',$status['tables_copiees']),'dump');
if ($callback_progression)
$callback_progression($status['tables_copiees'][$table],$status['tables_copiees'][$table],$table);
}
else {
if ($callback_progression)
$callback_progression(0,$status['tables_copiees'][$table],"$table".((is_numeric($status['tables_copiees'][$table]) AND $status['tables_copiees'][$table]>=0)?"[Echec]":""));
}
}
}
base_detruire_copieur_si_besoin($serveur_dest);
// OK, copie complete
return true;
}
/**
* fonction d'insertion en base lors de la copie de base a base
*
* @param string $table
* @param array $row
* @param array $desc_dest
* @param string $serveur_dest
* @return int/bool
*/
function base_inserer_copie($table,$row,$desc_dest,$serveur_dest){
// si l'enregistrement est deja en base, ca fera un echec ou un doublon
return sql_insertq($table,$row,$desc_dest,$serveur_dest);
}
?>
X
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// http://doc.spip.org/@base_admin_repair_dist
function base_repair_dist($titre='', $reprise='') {
$f = sql_repair('repair', NULL, 'continue');
if ($f) {
$res = admin_repair_tables();
} else {
if ($titre)
spip_log("Pas d'instruction REPAIR dans ce serveur SQL");
$res = ' ';
}
if (!$res) {
$res = "<br /><br /><span style='color: red; font-weight: bold;'><tt>"._T('avis_erreur_mysql').' '.sql_errno().': '.sql_error() ."</tt></span><br /><br /><br />\n";
} else {
include_spip('inc/rubriques');
calculer_rubriques();
propager_les_secteurs();
}
include_spip('inc/minipres');
$res .= pipeline('base_admin_repair',$res);
echo minipres(_T('texte_tentative_recuperation'),
$res . generer_form_ecrire('accueil', '','',_T('public:accueil_site')));
}
// http://doc.spip.org/@admin_repair_plat
function admin_repair_plat(){
spip_log("verification des documents joints");
$out = "";
$repertoire = array();
include_spip('inc/getdocument');
$res = sql_select('*','spip_documents',"fichier REGEXP CONCAT('^',extension,'[^/\]') AND distant='non'");
while ($row=sql_fetch($res)){
$ext = $row['extension'];
if (!$ext) {
spip_log("document sans extension: " . $row['id_document']);
continue;
}
if (!isset($repertoire[$ext])){
if (@file_exists($plat = _DIR_IMG. $ext .".plat"))
spip_unlink($plat);
$repertoire[$ext] = creer_repertoire_documents($ext);
if (preg_match(',_$,',$repertoire[$ext]))
$repertoire[$ext] = false;
}
if ($d=$repertoire[$ext]){
$d = substr($d,strlen(_DIR_IMG));
$src = $row['fichier'];
$dest = $d . substr($src,strlen($d));
if (@copy(_DIR_IMG . $src, _DIR_IMG . $dest)
AND file_exists(_DIR_IMG . $dest)) {
sql_updateq('spip_documents',array('fichier'=>$dest),'id_document='.intval($row['id_document']));
spip_unlink(_DIR_IMG . $src);
$out .= "$src => $dest<br />";
}
}
}
return $out;
}
// http://doc.spip.org/@admin_repair_tables
function admin_repair_tables() {
$connexion = $GLOBALS['connexions'][0];
$prefixe = $connexion['prefixe'];
$res1 = sql_showbase();
$res = "";
if ($res1) {
while ($r = sql_fetch($res1)) {
$tab = array_shift($r);
$res .= "<br /><b>$tab</b> ";
spip_log("Repare $tab");
// supprimer la meta avant de lancer la reparation
// car le repair peut etre long ; on ne veut pas boucler
effacer_meta('admin_repair');
$result_repair = sql_repair($tab);
if (!$result_repair) return false;
$count = sql_countsel($tab);
if ($count>1)
$res .= "("._T('texte_compte_elements', array('count' => $count)).")\n";
else if ($count==1)
$res .= "("._T('texte_compte_element', array('count' => $count)).")\n";
else
$res .= "("._T('texte_vide').")\n";
$msg = join(" ", sql_fetch($result_repair)) . ' ';
$ok = strpos($msg, ' OK ');
if (!$ok)
$res .= "<pre><span style='color: red; font-weight: bold;'>".htmlentities($msg)."</span></pre>\n";
else
$res .= " "._T('texte_table_ok')."<br />\n";
}
}
return $res;
}
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// http://doc.spip.org/@base_serial
function base_serial(&$tables_principales){
$spip_articles = array(
"id_article" => "bigint(21) NOT NULL",
"surtitre" => "text DEFAULT '' NOT NULL",
"titre" => "text DEFAULT '' NOT NULL",
"soustitre" => "text DEFAULT '' NOT NULL",
"id_rubrique" => "bigint(21) DEFAULT '0' NOT NULL",
"descriptif" => "text DEFAULT '' NOT NULL",
"chapo" => "mediumtext DEFAULT '' NOT NULL",
"texte" => "longtext DEFAULT '' NOT NULL",
"ps" => "mediumtext DEFAULT '' NOT NULL",
"date" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"statut" => "varchar(10) DEFAULT '0' NOT NULL",
"id_secteur" => "bigint(21) DEFAULT '0' NOT NULL",
"maj" => "TIMESTAMP",
"export" => "VARCHAR(10) DEFAULT 'oui'",
"date_redac" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"visites" => "integer DEFAULT '0' NOT NULL",
"referers" => "integer DEFAULT '0' NOT NULL",
"popularite" => "DOUBLE DEFAULT '0' NOT NULL",
"accepter_forum" => "CHAR(3) DEFAULT '' NOT NULL",
"date_modif" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"lang" => "VARCHAR(10) DEFAULT '' NOT NULL",
"langue_choisie" => "VARCHAR(3) DEFAULT 'non'",
"id_trad" => "bigint(21) DEFAULT '0' NOT NULL",
# "id_version" => "int unsigned DEFAULT '0' NOT NULL",
"nom_site" => "tinytext DEFAULT '' NOT NULL",
"url_site" => "VARCHAR(255) DEFAULT '' NOT NULL",
# "url_propre" => "VARCHAR(255) DEFAULT '' NOT NULL"
);
$spip_articles_key = array(
"PRIMARY KEY" => "id_article",
"KEY id_rubrique" => "id_rubrique",
"KEY id_secteur" => "id_secteur",
"KEY id_trad" => "id_trad",
"KEY lang" => "lang",
"KEY statut" => "statut, date",
# "KEY url_propre" => "url_propre"
);
$spip_articles_join = array(
"id_article"=>"id_article",
"id_rubrique"=>"id_rubrique");
$spip_auteurs = array(
"id_auteur" => "bigint(21) NOT NULL",
"nom" => "text DEFAULT '' NOT NULL",
"bio" => "text DEFAULT '' NOT NULL",
"email" => "tinytext DEFAULT '' NOT NULL",
"nom_site" => "tinytext DEFAULT '' NOT NULL",
"url_site" => "text DEFAULT '' NOT NULL",
"login" => "VARCHAR(255) BINARY",
"pass" => "tinytext DEFAULT '' NOT NULL",
"low_sec" => "tinytext DEFAULT '' NOT NULL",
"statut" => "varchar(255) DEFAULT '0' NOT NULL",
"webmestre" => "varchar(3) DEFAULT 'non' NOT NULL",
"maj" => "TIMESTAMP",
"pgp" => "TEXT DEFAULT '' NOT NULL",
"htpass" => "tinytext DEFAULT '' NOT NULL",
"en_ligne" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"imessage" => "VARCHAR(3)",
"messagerie" => "VARCHAR(3)",
"alea_actuel" => "tinytext",
"alea_futur" => "tinytext",
"prefs" => "tinytext",
"cookie_oubli" => "tinytext",
"source" => "VARCHAR(10) DEFAULT 'spip' NOT NULL",
"lang" => "VARCHAR(10) DEFAULT '' NOT NULL");
$spip_auteurs_key = array(
"PRIMARY KEY" => "id_auteur",
"KEY login" => "login",
"KEY statut" => "statut",
"KEY en_ligne" => "en_ligne",
# "KEY url_propre" => "url_propre"
);
$spip_auteurs_join = array(
"id_auteur"=>"id_auteur",
"login"=>"login");
$spip_messages = array(
"id_message" => "bigint(21) NOT NULL",
"titre" => "text DEFAULT '' NOT NULL",
"texte" => "longtext DEFAULT '' NOT NULL",
"type" => "varchar(6) DEFAULT '' NOT NULL",
"date_heure" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"date_fin" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"rv" => "varchar(3) DEFAULT '' NOT NULL",
"statut" => "varchar(6) DEFAULT '0' NOT NULL",
"id_auteur" => "bigint(21) NOT NULL",
"maj" => "TIMESTAMP");
$spip_messages_key = array(
"PRIMARY KEY" => "id_message",
"KEY id_auteur" => "id_auteur");
$spip_rubriques = array(
"id_rubrique" => "bigint(21) NOT NULL",
"id_parent" => "bigint(21) DEFAULT '0' NOT NULL",
"titre" => "text DEFAULT '' NOT NULL",
"descriptif" => "text DEFAULT '' NOT NULL",
"texte" => "longtext DEFAULT '' NOT NULL",
"id_secteur" => "bigint(21) DEFAULT '0' NOT NULL",
"maj" => "TIMESTAMP",
"export" => "VARCHAR(10) DEFAULT 'oui'",
"id_import" => "bigint DEFAULT '0'",
"statut" => "varchar(10) DEFAULT '0' NOT NULL",
"date" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"lang" => "VARCHAR(10) DEFAULT '' NOT NULL",
"langue_choisie" => "VARCHAR(3) DEFAULT 'non'",
"statut_tmp" => "varchar(10) DEFAULT '0' NOT NULL",
"date_tmp" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL"
);
$spip_rubriques_key = array(
"PRIMARY KEY" => "id_rubrique",
"KEY lang" => "lang",
"KEY id_parent" => "id_parent",
# "KEY url_propre" => "url_propre"
);
$spip_documents = array(
"id_document" => "bigint(21) NOT NULL",
"id_vignette" => "bigint(21) DEFAULT '0' NOT NULL",
"extension" => "VARCHAR(10) DEFAULT '' NOT NULL",
"titre" => "text DEFAULT '' NOT NULL",
"date" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
"descriptif" => "text DEFAULT '' NOT NULL",
"fichier" => "varchar(255) DEFAULT '' NOT NULL",
"taille" => "integer",
"largeur" => "integer",
"hauteur" => "integer",
"mode" => "ENUM('vignette', 'image', 'document') DEFAULT 'document' NOT NULL",
"distant" => "VARCHAR(3) DEFAULT 'non'",
"maj" => "TIMESTAMP");
$spip_documents_key = array(
"PRIMARY KEY" => "id_document",
"KEY id_vignette" => "id_vignette",
"KEY mode" => "mode",
"KEY extension" => "extension");
$spip_documents_join = array(
"id_document"=>"id_document",
"extension"=>"extension");
$spip_types_documents = array(
"extension" => "varchar(10) DEFAULT '' NOT NULL",
"titre" => "text DEFAULT '' NOT NULL",
"descriptif" => "text DEFAULT '' NOT NULL",
"mime_type" => "varchar(100) DEFAULT '' NOT NULL",
"inclus" => "ENUM('non', 'image', 'embed') DEFAULT 'non' NOT NULL",
"upload" => "ENUM('oui', 'non') DEFAULT 'oui' NOT NULL",
"maj" => "TIMESTAMP");
$spip_types_documents_key = array(
"PRIMARY KEY" => "extension",
"KEY inclus" => "inclus");
/// Attention: mes_fonctions peut avoir deja defini cette variable
/// il faut donc rajouter, mais pas reinitialiser
$tables_principales['spip_articles'] =
array('field' => &$spip_articles, 'key' => &$spip_articles_key, 'join' => &$spip_articles_join);
$tables_principales['spip_auteurs'] =
array('field' => &$spip_auteurs, 'key' => &$spip_auteurs_key,'join' => &$spip_auteurs_join);
$tables_principales['spip_messages'] =
array('field' => &$spip_messages, 'key' => &$spip_messages_key);
$tables_principales['spip_rubriques'] =
array('field' => &$spip_rubriques, 'key' => &$spip_rubriques_key);
$tables_principales['spip_documents'] =
array('field' => &$spip_documents, 'key' => &$spip_documents_key, 'join' => &$spip_documents_join);
$tables_principales['spip_types_documents'] =
array('field' => &$spip_types_documents, 'key' => &$spip_types_documents_key);
$tables_principales = pipeline('declarer_tables_principales',$tables_principales);
}
global $tables_principales;
base_serial($tables_principales);
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
include_spip('public/interfaces');
// Trouve la description d'une table, en particulier celle d'une boucle
// Si on ne la trouve pas, on demande au serveur SQL
// retourne False si lui non plus ne la trouve pas.
// Si on la trouve, le tableau resultat a les entrees:
// field (comme dans serial.php)
// key (comme dans serial.php)
// table = nom SQL de la table (avec le prefixe spip_ pour les stds)
// id_table = nom SPIP de la table (i.e. type de boucle)
// le compilateur produit FROM $r['table'] AS $r['id_table']
// Cette fonction intervient a la compilation,
// mais aussi pour la balise contextuelle EXPOSE.
// l'ensemble des descriptions de table d'un serveur est stocke dans un fichier cache/sql_desc.txt
// par soucis de performance
// un appel avec $nom vide est une demande explicite de vidange du cache des descriptions
// http://doc.spip.org/@base_trouver_table_dist
function base_trouver_table_dist($nom, $serveur='', $table_spip = true){
static $nom_cache_desc_sql=array();
global $tables_principales, $tables_auxiliaires, $table_des_tables;
if (!spip_connect($serveur)
OR !preg_match('/^[a-zA-Z0-9._-]*/',$nom))
return null;
$connexion = &$GLOBALS['connexions'][$serveur ? strtolower($serveur) : 0];
// le nom du cache depend du serveur mais aussi du nom de la db et du prefixe
// ce qui permet une auto invalidation en cas de modif manuelle du fichier
// de connexion, et tout risque d'ambiguite
if (!isset($nom_cache_desc_sql[$serveur]))
$nom_cache_desc_sql[$serveur] =
_DIR_CACHE . 'sql_desc_'
. ($serveur ? "$serveur_":"")
. substr(md5($connexion['db'].":".$connexion['prefixe']),0,8)
.'.txt';
// un appel avec $nom vide est une demande explicite de vidange du cache des descriptions
if (!$nom){
spip_unlink($nom_cache_desc_sql[$serveur]);
$connexion['tables'] = array();
return null;
}
$nom_sql = $nom;
if (preg_match('/\.(.*)$/', $nom, $s))
$nom_sql = $s[1];
else
$nom_sql = $nom;
$fdesc = $desc = '';
$connexion = &$GLOBALS['connexions'][$serveur ? $serveur : 0];
// base sous SPIP: gerer les abreviations explicites des noms de table
if ($connexion['spip_connect_version']) {
include_spip('public/interfaces');
if (isset($table_des_tables[$nom])) {
$nom = $table_des_tables[$nom];
$nom_sql = 'spip_' . $nom;
}
}
// si c'est la premiere table qu'on cherche
// et si on est pas explicitement en recalcul
// on essaye de recharger le cache des decriptions de ce serveur
// dans le fichier cache
if (!isset($connexion['tables'][$nom])
AND $GLOBALS['var_mode']!=='recalcul'
AND (!isset($connexion['tables']) OR !$connexion['tables'])) {
if (lire_fichier($nom_cache_desc_sql[$serveur],$desc_cache)
AND $desc_cache=unserialize($desc_cache))
$connexion['tables'] = $desc_cache;
}
if (!isset($connexion['tables'][$nom])) {
include_spip('base/serial');
if (isset($tables_principales[$nom_sql]))
$fdesc = $tables_principales[$nom_sql];
// meme si pas d'abreviation declaree, trouver la table spip_$nom
// si c'est une table principale,
// puisqu'on le fait aussi pour les tables auxiliaires
elseif ($nom_sql==$nom AND isset($tables_principales['spip_' .$nom])){
$nom_sql = 'spip_' . $nom;
$fdesc = &$tables_principales[$nom_sql];
}
else {
include_spip('base/auxiliaires');
if (isset($tables_auxiliaires['spip_' .$nom])) {
$nom_sql = 'spip_' . $nom;
$fdesc = &$tables_auxiliaires[$nom_sql];
} # table locale a cote de SPIP, comme non SPIP:
}
// La *vraie* base a la priorite
if (true /* !$bdesc OR !$bdesc['field'] */) {
$desc = sql_showtable($nom_sql, $table_spip, $serveur);
if (!$desc OR !$desc['field']) {
if (!$fdesc) {
spip_log("trouver_table: table inconnue '$serveur' '$nom'");
return null;
}
// on ne sait pas lire la structure de la table :
// on retombe sur la description donnee dans les fichiers spip
$desc = $fdesc;
}
}
// S'il n'y a pas de key (cas d'une VIEW),
// on va inventer une PRIMARY KEY en prenant le premier champ
// de la table
if (!$desc['key'])
$desc['key']['PRIMARY KEY'] = array_shift(array_keys($desc['field']));
$desc['table']= $nom_sql;
$desc['connexion']= $serveur;
// objet_type peut provoquer un appel reentrant ici.
// pour ne pas faire de boucle infinie, on stocke ce qu'on a deja trouve
$connexion['tables'][$nom] = $desc;
$surnom = (strpos($nom, $connexion['prefixe']) === 0) ? substr($nom, strlen($connexion['prefixe'])+1) : $nom;
$table = table_objet(objet_type($surnom));
$desc['titre'] =
isset($GLOBALS['table_titre'][$table]) ? $GLOBALS['table_titre'][$table] : '';
$desc['date'] =
isset($GLOBALS['table_date'][$table]) ? $GLOBALS['table_date'][$table] : '';
$connexion['tables'][$nom] = $desc;
// une nouvelle table a ete decrite
// mettons donc a jour le cache des descriptions de ce serveur
if (is_writeable(_DIR_CACHE))
ecrire_fichier($nom_cache_desc_sql[$serveur],serialize($connexion['tables']));
}
$connexion['tables'][$nom]['id_table']=$nom;
return $connexion['tables'][$nom];
}
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
//
if (!defined("_ECRIRE_INC_VERSION")) return;
global $tables_images, $tables_sequences, $tables_documents, $tables_mime, $mime_alias;
$tables_images = array(
// Images reconnues par PHP
'jpg' => 'JPEG',
'png' => 'PNG',
'gif' => 'GIF',
// Autres images (peuvent utiliser le tag <img>)
'bmp' => 'BMP',
'tif' => 'TIFF'
);
// Multimedia (peuvent utiliser le tag <embed>)
$tables_sequences = array(
'aiff' => 'AIFF',
'anx' => 'Annodex',
'axa' => 'Annodex Audio',
'axv' => 'Annodex Video',
'asf' => 'Windows Media',
'avi' => 'AVI',
'dv' => 'Digital Video',
'f4a' => 'Audio for Adobe Flash Player',
'f4b' => 'Audio Book for Adobe Flash Player',
'f4p' => 'Protected Video for Adobe Flash Player',
'f4v' => 'Video for Adobe Flash Player',
'flac' => 'Free Lossless Audio Codec',
'flv' => 'Flash Video',
'm4v' => 'MPEG4 Video',
'm4a' => 'MPEG4 Audio',
'm4b' => 'MPEG4 Audio',
'm4p' => 'MPEG4 Audio',
'mid' => 'Midi',
'mng' => 'MNG',
'mka' => 'Matroska Audio',
'mkv' => 'Matroska Video',
'mov' => 'QuickTime',
'mp3' => 'MP3',
'mp4' => 'MPEG4',
'mpc' => 'Musepack',
'mpg' => 'MPEG',
'oga' => 'Ogg Audio',
'ogg' => 'Ogg Vorbis',
'ogv' => 'Ogg Video',
'ogx' => 'Ogg Multiplex',
'qt' => 'QuickTime',
'ra' => 'RealAudio',
'ram' => 'RealAudio',
'rm' => 'RealAudio',
'spx' => 'Ogg Speex',
'svg' => 'Scalable Vector Graphics',
'swf' => 'Flash',
'wav' => 'WAV',
'webm' => 'WebM',
'wmv' => 'Windows Media',
'3gp' => '3rd Generation Partnership Project'
);
// Documents varies
$tables_documents = array(
'abw' => 'Abiword',
'ai' => 'Adobe Illustrator',
'bz2' => 'BZip',
'bin' => 'Binary Data',
'blend' => 'Blender',
'c' => 'C source',
'cls' => 'LaTeX Class',
'css' => 'Cascading Style Sheet',
'csv' => 'Comma Separated Values',
'deb' => 'Debian',
'doc' => 'Word',
'djvu' => 'DjVu',
'dvi' => 'LaTeX DVI',
'eps' => 'PostScript',
'gz' => 'GZ',
'h' => 'C header',
'html' => 'HTML',
'kml' => 'Keyhole Markup Language',
'kmz' => 'Google Earth Placemark File',
'm4u' => 'MPEG4 playliste',
'pas' => 'Pascal',
'pdf' => 'PDF',
'pgn' => 'Portable Game Notation',
'ppt' => 'PowerPoint',
'ps' => 'PostScript',
'psd' => 'Photoshop',
'rpm' => 'RedHat/Mandrake/SuSE',
'rtf' => 'RTF',
'sdd' => 'StarOffice',
'sdw' => 'StarOffice',
'sit' => 'Stuffit',
'sty' => 'LaTeX Style Sheet',
'sxc' => 'OpenOffice.org Calc',
'sxi' => 'OpenOffice.org Impress',
'sxw' => 'OpenOffice.org',
'tex' => 'LaTeX',
'tgz' => 'TGZ',
'torrent' => 'BitTorrent',
'ttf' => 'TTF Font',
'txt' => 'texte',
'xcf' => 'GIMP multi-layer',
'xspf' => 'XSPF',
'xls' => 'Excel',
'xml' => 'XML',
'zip' => 'Zip',
// open document format
'odt' => 'opendocument text',
'ods' => 'opendocument spreadsheet',
'odp' => 'opendocument presentation',
'odg' => 'opendocument graphics',
'odc' => 'opendocument chart',
'odf' => 'opendocument formula',
'odb' => 'opendocument database',
'odi' => 'opendocument image',
'odm' => 'opendocument text-master',
'ott' => 'opendocument text-template',
'ots' => 'opendocument spreadsheet-template',
'otp' => 'opendocument presentation-template',
'otg' => 'opendocument graphics-template',
// Open XML File Formats
'docm' => 'Word',
'docx' => 'Word',
'dotm' => 'Word template',
'dotx' => 'Word template',
'potm' => 'Powerpoint template',
'potx' => 'Powerpoint template',
'ppam' => 'Powerpoint addin',
'ppsm' => 'Powerpoint slideshow',
'ppsx' => 'Powerpoint slideshow',
'pptm' => 'Powerpoint',
'pptx' => 'Powerpoint',
'xlam' => 'Excel',
'xlsb' => 'Excel binary',
'xlsm' => 'Excel',
'xlsx' => 'Excel',
'xltm' => 'Excel template',
'xltx' => 'Excel template'
);
$tables_mime = array(
// Images reconnues par PHP
'jpg' => 'image/jpeg',
'png' => 'image/png',
'gif' => 'image/gif',
// Autres images (peuvent utiliser le tag <img>)
'bmp' => 'image/x-ms-bmp', // pas enregistre par IANA, variante: image/bmp
'tif' => 'image/tiff',
// Multimedia (peuvent utiliser le tag <embed>)
'aiff' => 'audio/x-aiff',
'asf' => 'video/x-ms-asf',
'avi' => 'video/x-msvideo',
'anx' => 'application/annodex',
'axa' => 'audio/annodex',
'axv' => 'video/annodex',
'dv' => 'video/x-dv',
'f4a' => 'audio/mp4',
'f4b' => 'audio/mp4',
'f4p' => 'video/mp4',
'f4v' => 'video/mp4',
'flac' => 'audio/x-flac',
'flv' => 'video/x-flv',
'm4a' => 'audio/mp4a-latm',
'm4b' => 'audio/mp4a-latm',
'm4p' => 'audio/mp4a-latm',
'm4u' => 'video/vnd.mpegurl',
'm4v' => 'video/x-m4v',
'mid' => 'audio/midi',
'mka' => 'audio/mka',
'mkv' => 'video/mkv',
'mng' => 'video/x-mng',
'mov' => 'video/quicktime',
'mp3' => 'audio/mpeg',
'mp4' => 'application/mp4',
'mpc' => 'audio/x-musepack',
'mpg' => 'video/mpeg',
'oga' => 'audio/ogg',
'ogg' => 'audio/ogg',
'ogv' => 'video/ogg',
'ogx' => 'application/ogg',
'qt' => 'video/quicktime',
'ra' => 'audio/x-pn-realaudio',
'ram' => 'audio/x-pn-realaudio',
'rm' => 'audio/x-pn-realaudio',
'spx' => 'audio/ogg',
'svg' => 'image/svg+xml',
'swf' => 'application/x-shockwave-flash',
'wav' => 'audio/x-wav',
'webm' => 'video/webm',
'wmv' => 'video/x-ms-wmv',
'3gp' => 'video/3gpp',
// Documents varies
'ai' => 'application/illustrator',
'abw' => 'application/abiword',
'bin' => 'application/octet-stream', # le tout-venant
'blend' => 'application/x-blender',
'bz2' => 'application/x-bzip2',
'c' => 'text/x-csrc',
'css' => 'text/css',
'csv' => 'text/csv',
'deb' => 'application/x-debian-package',
'doc' => 'application/msword',
'djvu' => 'image/vnd.djvu',
'dvi' => 'application/x-dvi',
'eps' => 'application/postscript',
'gz' => 'application/x-gzip',
'h' => 'text/x-chdr',
'html' => 'text/html',
'kml' => 'application/vnd.google-earth.kml+xml',
'kmz' => 'application/vnd.google-earth.kmz',
'pas' => 'text/x-pascal',
'pdf' => 'application/pdf',
'pgn' => 'application/x-chess-pgn',
'ppt' => 'application/vnd.ms-powerpoint',
'ps' => 'application/postscript',
'psd' => 'image/x-photoshop', // pas enregistre par IANA
'rpm' => 'application/x-redhat-package-manager',
'rtf' => 'application/rtf',
'sdd' => 'application/vnd.stardivision.impress',
'sdw' => 'application/vnd.stardivision.writer',
'sit' => 'application/x-stuffit',
'sxc' => 'application/vnd.sun.xml.calc',
'sxi' => 'application/vnd.sun.xml.impress',
'sxw' => 'application/vnd.sun.xml.writer',
'tex' => 'text/x-tex',
'tgz' => 'application/x-gtar',
'torrent' => 'application/x-bittorrent',
'ttf' => 'application/x-font-ttf',
'txt' => 'text/plain',
'xcf' => 'application/x-xcf',
'xls' => 'application/vnd.ms-excel',
'xspf' => 'application/xspf+xml',
'xml' => 'application/xml',
'zip' => 'application/zip',
// Open Document format
'odt' => 'application/vnd.oasis.opendocument.text',
'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
'odp' => 'application/vnd.oasis.opendocument.presentation',
'odg' => 'application/vnd.oasis.opendocument.graphics',
'odc' => 'application/vnd.oasis.opendocument.chart',
'odf' => 'application/vnd.oasis.opendocument.formula',
'odb' => 'application/vnd.oasis.opendocument.database',
'odi' => 'application/vnd.oasis.opendocument.image',
'odm' => 'application/vnd.oasis.opendocument.text-master',
'ott' => 'application/vnd.oasis.opendocument.text-template',
'ots' => 'application/vnd.oasis.opendocument.spreadsheet-template',
'otp' => 'application/vnd.oasis.opendocument.presentation-template',
'otg' => 'application/vnd.oasis.opendocument.graphics-template',
'cls' => 'text/x-tex',
'sty' => 'text/x-tex',
// Open XML File Formats
'docm' => 'application/vnd.ms-word.document.macroEnabled.12',
'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
'dotm' => 'application/vnd.ms-word.template.macroEnabled.12',
'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
'potm' => 'application/vnd.ms-powerpoint.template.macroEnabled.12',
'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
'ppam' => 'application/vnd.ms-powerpoint.addin.macroEnabled.12',
'ppsm' => 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12',
'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
'xlam' => 'application/vnd.ms-excel.addin.macroEnabled.12',
'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroEnabled.12',
'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
'xltm' => 'application/vnd.ms-excel.template.macroEnabled.12',
'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template'
);
$mime_alias = array (
'audio/x-mpeg' => 'audio/mpeg',
'audio/webm' => 'video/webm',
'audio/x-musepack' => 'audio/musepack',
'application/x-ogg' => 'application/ogg',
'video/mp4' => 'application/mp4',
'video/flv' => 'video/x-flv',
'audio/3gpp' => 'video/3gpp'
);
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// Programme de mise a jour des tables SQL lors d'un chgt de version.
// Marche aussi pour les plugins en appelant directement la fonction maj_while.
// Pour que ceux-ci profitent aussi de la reprise sur interruption,
// ils doivent indiquer leur numero de version installee dans une meta.
// Le nom de cette meta doit aussi etre un tableau global
// dont l'index "maj" est le sous-tableau des mises a jours
// et l'index "cible" la version a atteindre
// A tester.
// http://doc.spip.org/@base_upgrade_dist
function base_upgrade_dist($titre='', $reprise='')
{
if (!$titre) return; // anti-testeur automatique
if ($GLOBALS['spip_version']!=$GLOBALS['meta']['version_installee']) {
if (!is_numeric(_request('reinstall'))) {
include_spip('base/create');
spip_log("recree les tables eventuellement disparues");
creer_base();
}
$meta = _request('meta');
if (!$meta)
$res = maj_base();
// reprise sur demande de mise a jour interrompue pour plugin
else $res= maj_while($GLOBALS['meta'][$meta],
$GLOBALS[$meta]['cible'],
$GLOBALS[$meta]['maj'],
$meta,
_request('table'));
if ($res) {
if (!is_array($res))
spip_log("Pb d'acces SQL a la mise a jour");
else {
include_spip('inc/minipres');
echo minipres(_T('avis_operation_echec') . ' ' . join(' ', $res));
exit;
}
}
}
spip_log("Fin de mise a jour SQL. Debut m-a-j acces et config");
// supprimer quelques fichiers temporaires qui peuvent se retrouver invalides
spip_unlink(_DIR_TMP.'plugin_xml.cache');
spip_unlink(_DIR_SESSIONS.'ajax_fonctions.txt');
spip_unlink(_CACHE_PIPELINES);
spip_unlink(_CACHE_RUBRIQUES);
spip_unlink(_CACHE_PLUGINS_OPT);
spip_unlink(_CACHE_PLUGINS_FCT);
spip_unlink(_CACHE_PLUGINS_VERIF);
include_spip('inc/auth');
auth_synchroniser_distant();
$config = charger_fonction('config', 'inc');
$config();
}
// http://doc.spip.org/@maj_base
function maj_base($version_cible = 0) {
global $spip_version_base;
$version_installee = @$GLOBALS['meta']['version_installee'];
//
// Si version nulle ou inexistante, c'est une nouvelle installation
// => ne pas passer par le processus de mise a jour.
// De meme en cas de version superieure: ca devait etre un test,
// il y a eu le message d'avertissement il doit savoir ce qu'il fait
//
// version_installee = 1.702; quand on a besoin de forcer une MAJ
spip_log("Version anterieure: $version_installee. Courante: $spip_version_base");
if (!$version_installee OR ($spip_version_base < $version_installee)) {
sql_replace('spip_meta',
array('nom' => 'version_installee',
'valeur' => $spip_version_base,
'impt' => 'non'));
return false;
}
if (!upgrade_test()) return true;
$cible = ($version_cible ? $version_cible : $spip_version_base);
if ($version_installee <= 1.926) {
$n = floor($version_installee * 10);
while ($n < 19) {
$nom = sprintf("v%03d",$n);
$f = charger_fonction($nom, 'maj', true);
if ($f) {
spip_log("$f repercute les modifications de la version " . ($n/10));
$f($version_installee, $spip_version_base);
} else spip_log("pas de fonction pour la maj $n $nom");
$n++;
}
include_spip('maj/v019_pre193');
v019_pre193($version_installee, $version_cible);
}
if ($version_installee < 2000) {
if ($version_installee < 2)
$version_installee = $version_installee*1000;
include_spip('maj/v019');
}
if ($cible < 2)
$cible = $cible*1000;
include_spip('maj/svn10000');
return maj_while($version_installee, $cible, $GLOBALS['maj'], 'version_installee');
}
// A partir des > 1.926 (i.e SPIP > 1.9.2), cette fonction gere les MAJ.
// Se relancer soi-meme pour eviter l'interruption pendant une operation SQL
// (qu'on espere pas trop longue chacune)
// evidemment en ecrivant dans la meta a quel numero on en est.
// Cette fonction peut servir aux plugins qui doivent donner comme arguments:
// 1. le numero de version courant (nombre entier; ex: numero de commit)
// 2. le numero de version a atteindre (idem)
// 3. le tableau des instructions de mise a jour a executer
// Pour profiter du mecanisme de reprise sur interruption il faut de plus
// 4. le nom de la meta permettant de retrouver tout ca
// 5. la table des meta ou elle se trouve ($table_prefix . '_meta' par defaut)
// (cf debut de fichier)
// en cas d'echec, cette fonction retourne un tableau (etape,sous-etape)
// sinon elle retourne un tableau vide
define('_UPGRADE_TIME_OUT', 20);
// http://doc.spip.org/@maj_while
function maj_while($installee, $cible, $maj, $meta='', $table='meta')
{
$n = 0;
$time = time();
while ($installee < $cible) {
$installee++;
if (isset($maj[$installee])) {
$etape = serie_alter($installee, $maj[$installee], $meta, $table);
if ($etape) return array($installe, $etape);
$n = time() - $time;
spip_log("$table $meta: $installee en $n secondes",'maj');
if ($meta) ecrire_meta($meta, $installee,'non', $table);
} // rien pour SQL
if ($n >= _UPGRADE_TIME_OUT) {
redirige_url_ecrire('upgrade', "reinstall=$installee&meta=$meta&table=$table");
}
}
// indispensable pour les chgt de versions qui n'ecrivent pas en base
// tant pis pour la redondance eventuelle avec ci-dessus
if ($meta) ecrire_meta($meta, $installee,'non');
spip_log("MAJ terminee. $meta: $installee",'maj');
return array();
}
// Appliquer une serie de chgt qui risquent de partir en timeout
// (Alter cree une copie temporaire d'une table, c'est lourd)
// http://doc.spip.org/@serie_alter
function serie_alter($serie, $q = array(), $meta='', $table='meta') {
$meta .= '_maj_' . $serie;
$etape = intval(@$GLOBALS[$table][$meta]);
foreach ($q as $i => $r) {
if ($i >= $etape) {
$msg = "maj $table $meta etape $i";
if (is_array($r)
AND function_exists($f = array_shift($r))) {
spip_log("$msg: $f " . join(',',$r),'maj');
ecrire_meta($meta, $i+1, 'non', $table); // attention on enregistre le meta avant de lancer la fonction, de maniere a eviter de boucler sur timeout
call_user_func_array($f, $r);
spip_log("$meta: ok", 'maj');
} else return $i+1;
}
}
effacer_meta($meta, $table);
return 0;
}
// La fonction a appeler dans le tableau global $maj
// quand on rajoute des types MIME. cf par exemple la 1.953
// http://doc.spip.org/@upgrade_types_documents
function upgrade_types_documents() {
include_spip('base/create');
creer_base_types_doc();
}
// http://doc.spip.org/@upgrade_test
function upgrade_test() {
sql_drop_table("spip_test", true);
sql_create("spip_test", array('a' => 'int'));
sql_alter("TABLE spip_test ADD b INT");
sql_insertq('spip_test', array('b' => 1), array('field'=>array('b' => 'int')));
$result = sql_select('b', "spip_test");
// ne pas garder le resultat de la requete sinon sqlite3
// ne peut pas supprimer la table spip_test lors du sql_alter qui suit
// car cette table serait alors 'verouillee'
$result = $result?true:false;
sql_alter("TABLE spip_test DROP b");
return $result;
}
// pour versions <= 1.926
// http://doc.spip.org/@maj_version
function maj_version ($version, $test = true) {
if ($test) {
if ($version>=1.922)
ecrire_meta('version_installee', $version, 'non');
else {
// on le fait manuellement, car ecrire_meta utilise le champs impt qui est absent sur les vieilles versions
$GLOBALS['meta']['version_installee'] = $version;
sql_updateq('spip_meta', array('valeur' => $version), "nom=" . sql_quote('version_installee') );
}
spip_log("mise a jour de la base en $version");
} else {
echo _T('alerte_maj_impossible', array('version' => $version));
exit;
}
}
// pour versions <= 1.926
// http://doc.spip.org/@upgrade_vers
function upgrade_vers($version, $version_installee, $version_cible = 0){
return ($version_installee<$version
AND (($version_cible>=$version) OR ($version_cible==0))
);
}
?>
<?php
// cp1250 - Mathieu Lutfy - ref.
// http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1250.TXT
$GLOBALS['CHARSET']['cp1250'] = array (
0x80 => 0x20AC, 0x82 => 0x201A,
0x84 => 0x201E, 0x85 => 0x2026, 0x86 => 0x2020,
0x87 => 0x2021, 0x89 => 0x2030, 0x8A => 0x0160,
0x8B => 0x2039, 0x8C => 0x015A, 0x8D => 0x0164,
0x8E => 0x017D, 0x8F => 0x0179, 0x91 => 0x2018,
0x92 => 0x2019, 0x93 => 0x201C, 0x94 => 0x201D,
0x95 => 0x2022, 0x96 => 0x2013, 0x97 => 0x2014,
0x99 => 0x2122, 0x9A => 0x0161, 0x9B => 0x203A,
0x9C => 0x015B, 0x9D => 0x0165, 0x9E => 0x017E,
0x9F => 0x017A, 0xA0 => 0x00A0, 0xA1 => 0x02C7,
0xA2 => 0x02D8, 0xA3 => 0x0141, 0xA4 => 0x00A4,
0xA5 => 0x0104, 0xA6 => 0x00A6, 0xA7 => 0x00A7,
0xA8 => 0x00A8, 0xA9 => 0x00A9, 0xAA => 0x015E,
0xAB => 0x00AB, 0xAC => 0x00AC, 0xAD => 0x00AD,
0xAE => 0x00AE, 0xAF => 0x017B, 0xB0 => 0x00B0,
0xB1 => 0x00B1, 0xB2 => 0x02DB, 0xB3 => 0x0142,
0xB4 => 0x00B4, 0xB5 => 0x00B5, 0xB6 => 0x00B6,
0xB7 => 0x00B7, 0xB8 => 0x00B8, 0xB9 => 0x0105,
0xBA => 0x015F, 0xBB => 0x00BB, 0xBC => 0x013D,
0xBD => 0x02DD, 0xBE => 0x013E, 0xBF => 0x017C,
0xC0 => 0x0154, 0xC1 => 0x00C1, 0xC2 => 0x00C2,
0xC3 => 0x0102, 0xC4 => 0x00C4, 0xC5 => 0x0139,
0xC6 => 0x0106, 0xC7 => 0x00C7, 0xC8 => 0x010C,
0xC9 => 0x00C9, 0xCA => 0x0118, 0xCB => 0x00CB,
0xCC => 0x011A, 0xCD => 0x00CD, 0xCE => 0x00CE,
0xCF => 0x010E, 0xD0 => 0x0110, 0xD1 => 0x0143,
0xD2 => 0x0147, 0xD3 => 0x00D3, 0xD4 => 0x00D4,
0xD5 => 0x0150, 0xD6 => 0x00D6, 0xD7 => 0x00D7,
0xD8 => 0x0158, 0xD9 => 0x016E, 0xDA => 0x00DA,
0xDB => 0x0170, 0xDC => 0x00DC, 0xDD => 0x00DD,
0xDE => 0x0162, 0xDF => 0x00DF, 0xE0 => 0x0155,
0xE1 => 0x00E1, 0xE2 => 0x00E2, 0xE3 => 0x0103,
0xE4 => 0x00E4, 0xE5 => 0x013A, 0xE6 => 0x0107,
0xE7 => 0x00E7, 0xE8 => 0x010D, 0xE9 => 0x00E9,
0xEA => 0x0119, 0xEB => 0x00EB, 0xEC => 0x011B,
0xED => 0x00ED, 0xEE => 0x00EE, 0xEF => 0x010F,
0xF0 => 0x0111, 0xF1 => 0x0144, 0xF2 => 0x0148,
0xF3 => 0x00F3, 0xF4 => 0x00F4, 0xF5 => 0x0151,
0xF6 => 0x00F6, 0xF7 => 0x00F7, 0xF8 => 0x0159,
0xF9 => 0x016F, 0xFA => 0x00FA, 0xFB => 0x0171,
0xFC => 0x00FC, 0xFD => 0x00FD, 0xFE => 0x0163,
0xFF => 0x02D9 );
?>
<?php
// cyrillic - ref. http://czyborra.com/charsets/cyrillic.html
$GLOBALS['CHARSET']['cp1251'] = array (
0x80=>0x0402, 0x81=>0x0403, 0x82=>0x201A, 0x83=>0x0453, 0x84=>0x201E,
0x85=>0x2026, 0x86=>0x2020, 0x87=>0x2021, 0x88=>0x20AC, 0x89=>0x2030,
0x8A=>0x0409, 0x8B=>0x2039, 0x8C=>0x040A, 0x8D=>0x040C, 0x8E=>0x040B,
0x8F=>0x040F, 0x90=>0x0452, 0x91=>0x2018, 0x92=>0x2019, 0x93=>0x201C,
0x94=>0x201D, 0x95=>0x2022, 0x96=>0x2013, 0x97=>0x2014, 0x99=>0x2122,
0x9A=>0x0459, 0x9B=>0x203A, 0x9C=>0x045A, 0x9D=>0x045C, 0x9E=>0x045B,
0x9F=>0x045F, 0xA0=>0x00A0, 0xA1=>0x040E, 0xA2=>0x045E, 0xA3=>0x0408,
0xA4=>0x00A4, 0xA5=>0x0490, 0xA6=>0x00A6, 0xA7=>0x00A7, 0xA8=>0x0401,
0xA9=>0x00A9, 0xAA=>0x0404, 0xAB=>0x00AB, 0xAC=>0x00AC, 0xAD=>0x00AD,
0xAE=>0x00AE, 0xAF=>0x0407, 0xB0=>0x00B0, 0xB1=>0x00B1, 0xB2=>0x0406,
0xB3=>0x0456, 0xB4=>0x0491, 0xB5=>0x00B5, 0xB6=>0x00B6, 0xB7=>0x00B7,
0xB8=>0x0451, 0xB9=>0x2116, 0xBA=>0x0454, 0xBB=>0x00BB, 0xBC=>0x0458,
0xBD=>0x0405, 0xBE=>0x0455, 0xBF=>0x0457, 0xC0=>0x0410, 0xC1=>0x0411,
0xC2=>0x0412, 0xC3=>0x0413, 0xC4=>0x0414, 0xC5=>0x0415, 0xC6=>0x0416,
0xC7=>0x0417, 0xC8=>0x0418, 0xC9=>0x0419, 0xCA=>0x041A, 0xCB=>0x041B,
0xCC=>0x041C, 0xCD=>0x041D, 0xCE=>0x041E, 0xCF=>0x041F, 0xD0=>0x0420,
0xD1=>0x0421, 0xD2=>0x0422, 0xD3=>0x0423, 0xD4=>0x0424, 0xD5=>0x0425,
0xD6=>0x0426, 0xD7=>0x0427, 0xD8=>0x0428, 0xD9=>0x0429, 0xDA=>0x042A,
0xDB=>0x042B, 0xDC=>0x042C, 0xDD=>0x042D, 0xDE=>0x042E, 0xDF=>0x042F,
0xE0=>0x0430, 0xE1=>0x0431, 0xE2=>0x0432, 0xE3=>0x0433, 0xE4=>0x0434,
0xE5=>0x0435, 0xE6=>0x0436, 0xE7=>0x0437, 0xE8=>0x0438, 0xE9=>0x0439,
0xEA=>0x043A, 0xEB=>0x043B, 0xEC=>0x043C, 0xED=>0x043D, 0xEE=>0x043E,
0xEF=>0x043F, 0xF0=>0x0440, 0xF1=>0x0441, 0xF2=>0x0442, 0xF3=>0x0443,
0xF4=>0x0444, 0xF5=>0x0445, 0xF6=>0x0446, 0xF7=>0x0447, 0xF8=>0x0448,
0xF9=>0x0449, 0xFA=>0x044A, 0xFB=>0x044B, 0xFC=>0x044C, 0xFD=>0x044D,
0xFE=>0x044E, 0xFF=>0x044F);
?>
<?php
// arabic - george kandalaft
// http://www.microsoft.com/typography/unicode/1256.htm
$GLOBALS['CHARSET']['cp1256'] = array (
0x80=>0x20AC, 0x81=>0x067E, 0x82=>0x201A, 0x83=>0x0192, 0x84=>0x201E,
0x85=>0x2026, 0x86=>0x2020, 0x87=>0x2021, 0x88=>0x02C6, 0x89=>0x2030,
0x8A=>0x0679, 0x8B=>0x2039, 0x8C=>0x0152, 0x8D=>0x0686, 0x8E=>0x0698,
0x8F=>0x0688, 0x90=>0x06AF, 0x91=>0x2018, 0x92=>0x2019, 0x93=>0x201C,
0x94=>0x201D, 0x95=>0x2022, 0x96=>0x2013, 0x97=>0x2014, 0x98=>0x06A9,
0x99=>0x2122, 0x9A=>0x0691, 0x9B=>0x203A, 0x9C=>0x0153, 0x9D=>0x200C,
0x9E=>0x200D, 0x9F=>0x06BA, 0xA0=>0x00A0, 0xA1=>0x060C, 0xA2=>0x00A2,
0xA3=>0x00A3, 0xA4=>0x00A4, 0xA5=>0x00A5, 0xA6=>0x00A6, 0xA7=>0x00A7,
0xA8=>0x00A8, 0xA9=>0x00A9, 0xAA=>0x06BE, 0xAB=>0x00AB, 0xAC=>0x00AC,
0xAD=>0x00AD, 0xAE=>0x00AE, 0xAF=>0x00AF, 0xB0=>0x00B0, 0xB1=>0x00B1,
0xB2=>0x00B2, 0xB3=>0x00B3, 0xB4=>0x00B4, 0xB5=>0x00B5, 0xB6=>0x00B6,
0xB7=>0x00B7, 0xB8=>0x00B8, 0xB9=>0x00B9, 0xBA=>0x061B, 0xBB=>0x00BB,
0xBC=>0x00BC, 0xBD=>0x00BD, 0xBE=>0x00BE, 0xBF=>0x061F, 0xC0=>0x06C1,
0xC1=>0x0621, 0xC2=>0x0622, 0xC3=>0x0623, 0xC4=>0x0624, 0xC5=>0x0625,
0xC6=>0x0626, 0xC7=>0x0627, 0xC8=>0x0628, 0xC9=>0x0629, 0xCA=>0x062A,
0xCB=>0x062B, 0xCC=>0x062C, 0xCD=>0x062D, 0xCE=>0x062E, 0xCF=>0x062F,
0xD0=>0x0630, 0xD1=>0x0631, 0xD2=>0x0632, 0xD3=>0x0633, 0xD4=>0x0634,
0xD5=>0x0635, 0xD6=>0x0636, 0xD7=>0x00D7, 0xD8=>0x0637, 0xD9=>0x0638,
0xDA=>0x0639, 0xDB=>0x063A, 0xDC=>0x0640, 0xDD=>0x0641, 0xDE=>0x0642,
0xDF=>0x0643, 0xE0=>0x00E0, 0xE1=>0x0644, 0xE2=>0x00E2, 0xE3=>0x0645,
0xE4=>0x0646, 0xE5=>0x0647, 0xE6=>0x0648, 0xE7=>0x00E7, 0xE8=>0x00E8,
0xE9=>0x00E9, 0xEA=>0x00EA, 0xEB=>0x00EB, 0xEC=>0x0649, 0xED=>0x064A,
0xEE=>0x00EE, 0xEF=>0x00EF, 0xF0=>0x064B, 0xF1=>0x064C, 0xF2=>0x064D,
0xF3=>0x064E, 0xF4=>0x00F4, 0xF5=>0x064F, 0xF6=>0x0650, 0xF7=>0x00F7,
0xF8=>0x0651, 0xF9=>0x00F9, 0xFA=>0x0652, 0xFB=>0x00FB, 0xFC=>0x00FC,
0xFD=>0x200E, 0xFE=>0x200F, 0xFF=>0x06D2);
?>
<?php
// entites html (a completer eventuellement)
$GLOBALS['CHARSET']['html'] = array (
'ldquo'=>'&#8220;', 'rdquo'=>'&#8221;', 'bdquo'=>'&#8222;', 'cent'=>'&#162;', 'pound'=>'&#163;',
'curren'=>'&#164;', 'yen'=>'&#165;', 'brvbar'=>'&#166;', 'sect'=>'&#167;',
'uml'=>'&#168;', 'ordf'=>'&#170;', 'laquo'=>'&#171;', 'lsquo'=>'&#8216;', 'rsquo'=>'&#8217;', 'not'=>'&#172;',
'shy'=>'&#173;', 'macr'=>'&#175;', 'deg'=>'&#176;', 'plusmn'=>'&#177;',
'sup2'=>'&#178;', 'sup3'=>'&#179;', 'acute'=>'&#180;', 'micro'=>'&#181;',
'para'=>'&#182;', 'middot'=>'&#183;', 'cedil'=>'&#184;', 'sup1'=>'&#185;',
'ordm'=>'&#186;', 'raquo'=>'&#187;', 'iquest'=>'&#191;', 'Agrave'=>'&#192;',
'Aacute'=>'&#193;', 'Acirc'=>'&#194;', 'Atilde'=>'&#195;', 'Auml'=>'&#196;',
'Aring'=>'&#197;', 'AElig'=>'&#198;', 'Ccedil'=>'&#199;', 'Egrave'=>'&#200;',
'Eacute'=>'&#201;', 'Ecirc'=>'&#202;', 'Euml'=>'&#203;', 'Igrave'=>'&#204;',
'Iacute'=>'&#205;', 'Icirc'=>'&#206;', 'Iuml'=>'&#207;', 'ETH'=>'&#208;',
'Ntilde'=>'&#209;', 'Ograve'=>'&#210;', 'Oacute'=>'&#211;', 'Ocirc'=>'&#212;',
'Otilde'=>'&#213;', 'Ouml'=>'&#214;', 'times'=>'&#215;', 'Oslash'=>'&#216;',
'Ugrave'=>'&#217;', 'Uacute'=>'&#218;', 'Ucirc'=>'&#219;', 'Uuml'=>'&#220;',
'Yacute'=>'&#221;', 'THORN'=>'&#222;', 'szlig'=>'&#223;', 'agrave'=>'&#224;',
'Scaron'=>'&#352;', 'scaron'=>'&#353;', 'zcaron'=>'&#x17E;', 'Zcaron'=>'&#x17D;',
'aacute'=>'&#225;', 'acirc'=>'&#226;', 'atilde'=>'&#227;', 'auml'=>'&#228;',
'aring'=>'&#229;', 'aelig'=>'&#230;', 'ccedil'=>'&#231;', 'egrave'=>'&#232;',
'eacute'=>'&#233;', 'ecirc'=>'&#234;', 'euml'=>'&#235;', 'igrave'=>'&#236;',
'iacute'=>'&#237;', 'icirc'=>'&#238;', 'iuml'=>'&#239;', 'eth'=>'&#240;',
'ntilde'=>'&#241;', 'ograve'=>'&#242;', 'oacute'=>'&#243;', 'ocirc'=>'&#244;',
'otilde'=>'&#245;', 'ouml'=>'&#246;', 'divide'=>'&#247;', 'oslash'=>'&#248;',
'ugrave'=>'&#249;', 'uacute'=>'&#250;', 'ucirc'=>'&#251;', 'uuml'=>'&#252;',
'yacute'=>'&#253;', 'thorn'=>'&#254;', 'nbsp' => " ", 'thinsp' =>'&#8201;', 'ensp' =>'&#8194;', 'emsp' =>'&#8195;', 'copy' => "(c)",
'reg' => "(r)", 'frac14' => "1/4", 'frac12' => "1/2", 'frac34' => "3/4",
'apos' => "'", 'mdash' => '&#8212;', 'ndash' => '&#8211;', 'hellip' =>'&#8230;',
'euro' => '&#8364;', 'OElig' => '&#338;', 'oelig' => '&#339;','iexcl' => '&#161;'
);
## caracteres tres speciaux a ne pas convertir
#'amp' => '&', 'quot' => '"', 'lt' => '<', 'gt' => '>',
?>
X
<?php
# charset iso-8859-1
$GLOBALS['CHARSET']['iso-8859-1'] = array (
// plage invalide en iso-8859-1 mais souvent utilisee quand meme (windows)
// cf. http://openweb.eu.org/articles/caracteres_illegaux/
// voir aussi copie de ces valeurs dans inc/charsets.php
128=>8364, 129=>129 /* ?? */, 130=>8218, 131=>402, 132=>8222, 133=>8230,
134=>8224, 135=>8225, 136=>710, 137=>8240, 138=>352, 139=>8249, 140=>338,
141=>141 /* ?? */, 142=>381, 143=>143 /* ?? */, 144=>144 /* ?? */, 145=>8216,
146=>8217, 147=>8220, 148=>8221, 149=>8226, 150=>8211, 151=>8212, 152=>732,
153=>8482, 154=>353, 155=>8250, 156=>339, 157=>157 /* ?? */, 158=>382, 159=>376,
160=>160, 161=>161, 162=>162, 163=>163, 164=>164, 165=>165, 166=>166, 167=>167,
168=>168, 169=>169, 170=>170, 171=>171, 172=>172, 173=>173, 174=>174, 175=>175,
176=>176, 177=>177, 178=>178, 179=>179, 180=>180, 181=>181, 182=>182, 183=>183,
184=>184, 185=>185, 186=>186, 187=>187, 188=>188, 189=>189, 190=>190, 191=>191,
192=>192, 193=>193, 194=>194, 195=>195, 196=>196, 197=>197, 198=>198, 199=>199,
200=>200, 201=>201, 202=>202, 203=>203, 204=>204, 205=>205, 206=>206, 207=>207,
208=>208, 209=>209, 210=>210, 211=>211, 212=>212, 213=>213, 214=>214, 215=>215,
216=>216, 217=>217, 218=>218, 219=>219, 220=>220, 221=>221, 222=>222, 223=>223,
224=>224, 225=>225, 226=>226, 227=>227, 228=>228, 229=>229, 230=>230, 231=>231,
232=>232, 233=>233, 234=>234, 235=>235, 236=>236, 237=>237, 238=>238, 239=>239,
240=>240, 241=>241, 242=>242, 243=>243, 244=>244, 245=>245, 246=>246, 247=>247,
248=>248, 249=>249, 250=>250, 251=>251, 252=>252, 253=>253, 254=>254, 255=>255
);
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// iso latin 15 - Gaetan Ryckeboer <gryckeboer@virtual-net.fr>
load_charset('iso-8859-1');
$trans = $GLOBALS['CHARSET']['iso-8859-1'];
$trans[164]=8364;
$trans[166]=352;
$trans[168]=353;
$trans[180]=381;
$trans[184]=382;
$trans[188]=338;
$trans[189]=339;
$trans[190]=376;
$GLOBALS['CHARSET']['iso-8859-15'] = $trans;
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// arabic iso-8859-6 - http://czyborra.com/charsets/iso8859.html#ISO-8859-6
load_charset('iso-8859-1');
$trans = $GLOBALS['CHARSET']['iso-8859-1'];
$mod = Array(
0xA0=>0x00A0, 0xA4=>0x00A4, 0xAC=>0x060C, 0xAD=>0x00AD, 0xBB=>0x061B,
0xBF=>0x061F, 0xC1=>0x0621, 0xC2=>0x0622, 0xC3=>0x0623, 0xC4=>0x0624,
0xC5=>0x0625, 0xC6=>0x0626, 0xC7=>0x0627, 0xC8=>0x0628, 0xC9=>0x0629,
0xCA=>0x062A, 0xCB=>0x062B, 0xCC=>0x062C, 0xCD=>0x062D, 0xCE=>0x062E,
0xCF=>0x062F, 0xD0=>0x0630, 0xD1=>0x0631, 0xD2=>0x0632, 0xD3=>0x0633,
0xD4=>0x0634, 0xD5=>0x0635, 0xD6=>0x0636, 0xD7=>0x0637, 0xD8=>0x0638,
0xD9=>0x0639, 0xDA=>0x063A, 0xE0=>0x0640, 0xE1=>0x0641, 0xE2=>0x0642,
0xE3=>0x0643, 0xE4=>0x0644, 0xE5=>0x0645, 0xE6=>0x0646, 0xE7=>0x0647,
0xE8=>0x0648, 0xE9=>0x0649, 0xEA=>0x064A, 0xEB=>0x064B, 0xEC=>0x064C,
0xED=>0x064D, 0xEE=>0x064E, 0xEF=>0x064F, 0xF0=>0x0650, 0xF1=>0x0651,
0xF2=>0x0652
);
foreach ($mod as $num=>$val)
$trans[$num]=$val;
$GLOBALS['CHARSET']['iso-8859-6'] = $trans;
?>
<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2010 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
if (!defined("_ECRIRE_INC_VERSION")) return;
// iso latin 9 - Turc <alexis@nds.k12.tr>
load_charset('iso-8859-1');
$trans = $GLOBALS['CHARSET']['iso-8859-1'];
$trans[240]=287; //gbreve
$trans[208]=286; //Gbreve
$trans[221]=304; //Idot
$trans[253]=305; //inodot
$trans[254]=351; //scedil
$trans[222]=350; //Scedil
$GLOBALS['CHARSET']['iso-8859-9'] = $trans;
?>
<?php
// mathml
$GLOBALS['CHARSET']['mathml'] = array (
'ac' => '&#xE207;',
'acd' => '&#xE3A6;',
'acE' => '&E#290;',
'acute' => '&#x0301;',
'Afr' => '&#xE47C;',
'afr' => '&#xE495;',
'aleph' => '&#x2135;',
'alpha' => '&#x03B1;',
'amalg' => '&#xE251;',
'amp' => '&#x0026;',
'And' => '&#x2227;',
'and' => '&#x2227;',
'andand' => '&#xE36E;',
'andd' => '&#xE394;',
'andslope' => '&#xE50A;',
'andv' => '&#xE391;',
'ang' => '&#x2220;',
'ange' => '&#xE2D6;',
'angle' => '&#x2220;',
'angmsd' => '&#x2221;',
'angmsdaa' => '&#xE2D9;',
'angmsdab' => '&#xE2DA;',
'angmsdac' => '&#xE2DB;',
'angmsdad' => '&#xE2DC;',
'angmsdae' => '&#xE2DD;',
'angmsdaf' => '&#xE2DE;',
'angmsdag' => '&#xE2DF;',
'angmsdah' => '&#xE2E0;',
'angrt' => '&#x221F;',
'angrtvb' => '&#xE418;',
'angrtvbd' => '&#xE2E1;',
'angsph' => '&#x2222;',
'angst' => '&#x212B;',
'angzarr' => '&#xE248;',
'Aopf' => '&#xE4AF;',
'ap' => '&#x2248;',
'apacir' => '&#xE38C;',
'apE' => '&#xE315;',
'ape' => '&#x224A;',
'apid' => '&#x224B;',
'apos' => '&#x0027;',
'approx' => '&#x2248;',
'approxeq' => '&#x224A;',
'Ascr' => '&#xE4C5;',
'ascr' => '&#xE4DF;',
'ast' => '&#x2217;',
'asymp' => '&#x224D;',
'awconint' => '&#x2233;',
'awint' => '&#xE39B;',
'backcong' => '&#x224C;',
'backepsilon' => '&#xE420;',
'backprime' => '&#x2035;',
'backsim' => '&#x223D;',
'backsimeq' => '&#x22CD;',
'Backslash' => '&#x2216;',
'Barv' => '&#xE311;',
'barvee' => '&#x22BD;',
'Barwed' => '&#x2306;',
'barwed' => '&#x22BC;',
'barwedge' => '&#x22BC;',
'bbrk' => '&#xE2EE;',
'bbrktbrk' => '&#xE419;',
'bcong' => '&#x224C;',
'becaus' => '&#x2235;',
'Because' => '&#x2235;',
'because' => '&#x2235;',
'bemptyv' => '&#xE41A;',
'benzen' => '&#xE43C;',
'benzena' => '&#xE42A;',
'benzenb' => '&#xE42B;',
'benzenc' => '&#xE42C;',
'benzend' => '&#xE42D;',
'benzene' => '&#xE42E;',
'benzenf' => '&#xE42F;',
'benzeng' => '&#xE430;',
'benzenh' => '&#xE431;',
'benzeni' => '&#xE432;',
'benzenj' => '&#xE433;',
'benzenk' => '&#xE434;',
'benzenl' => '&#xE435;',
'benzenm' => '&#xE436;',
'benzenn' => '&#xE437;',
'benzeno' => '&#xE438;',
'benzenp' => '&#xE439;',
'benzenq' => '&#xE43A;',
'benzenr' => '&#xE43B;',
'bepsi' => '&#xE420;',
'bernou' => '&#x212C;',
'beta' => '&#x03B2;',
'beth' => '&#x2136;',
'between' => '&#x226C;',
'Bfr' => '&#xE47D;',
'bfr' => '&#xE496;',
'bigcap' => '&#x22C2;',
'bigcirc' => '&#x25CB;',
'bigcup' => '&#x22C3;',
'bigodot' => '&#x2299;',
'bigoplus' => '&#x2295;',
'bigotimes' => '&#x2297;',
'bigsqcup' => '&#x2294;',
'bigstar' => '&#x2605;',
'bigtriangledown' => '&#x25BD;',
'bigtriangleup' => '&#x25B3;',
'biguplus' => '&#x228E;',
'bigvee' => '&#x22C1;',
'bigwedge' => '&#x22C0;',
'bkarow' => '&#xE405;',
'blacklozenge' => '&#xE501;',
'blacksquare' => '&#x25A0;',
'blacktriangle' => '&#x25B4;',
'blacktriangledown' => '&#x25BE;',
'blacktriangleleft' => '&#x25C2;',
'blacktriangleright' => '&#x25B8;',
'blank' => '&#xE4F9;',
'blk12' => '&#x2592;',
'blk14' => '&#x2591;',
'blk34' => '&#x2593;',
'block' => '&#x2588;',
'bne' => '&#xE388;',
'bnequiv' => '&#xE387;',
'bNot' => '&#xE3AD;',
'bnot' => '&#x2310;',
'Bopf' => '&#xE4B0;',
'bot' => '&#x22A5;',
'bottom' => '&#x22A5;',
'bowtie' => '&#x22C8;',
'boxbox' => '&#xE2E6;',
'boxminus' => '&#x229F;',
'boxplus' => '&#x229E;',
'boxtimes' => '&#x22A0;',
'bprime' => '&#x2035;',
'Breve' => '&#x0306;',
'breve' => '&#x0306;',
'brvbar' => '&#x00A6;',
'Bscr' => '&#xE4C6;',
'bscr' => '&#xE4E0;',
'bsemi' => '&#xE2ED;',
'bsim' => '&#x223D;',
'bsime' => '&#x22CD;',
'bsol' => '&#x005C;',
'bsolb' => '&#xE280;',
'bsolhsub' => '&#xE34D;',
'bull' => '&#x2022;',
'bullet' => '&#x2022;',
'bump' => '&#x224E;',
'bumpe' => '&#x224F;',
'Bumpeq' => '&#x224E;',
'bumpeq' => '&#x224F;',
'Cap' => '&#x22D2;',
'cap' => '&#x2229;',
'capand' => '&#xE281;',
'capbrcup' => '&#xE271;',
'capcap' => '&#xE273;',
'capcup' => '&#xE26F;',
'capdot' => '&#xE261;',
'caps' => '&#xE275;',
'caret' => '&#x2038;',
'caron' => '&#x030C;',
'ccaps' => '&#xE279;',
'Cconint' => '&#x2230;',
'ccups' => '&#xE278;',
'ccupssm' => '&#xE27A;',
'cdot' => '&#x22C5;',
'cedil' => '&#x0327;',
'Cedilla' => '&#x0327;',
'cemptyv' => '&#xE2E8;',
'cent' => '&#x00A2;',
'CenterDot' => '&#x00B7;',
'centerdot' => '&#x00B7;',
'Cfr' => '&#xE47E;',
'cfr' => '&#xE497;',
'check' => '&#x2713;',
'checkmark' => '&#x2713;',
'chi' => '&#x03C7;',
'cir' => '&#x2218;',
'circ' => '&#x2218;',
'circeq' => '&#x2257;',
'circle' => '&#xE4FA;',
'circlearrowleft' => '&#x21BA;',
'circlearrowright' => '&#x21BB;',
'circledast' => '&#x229B;',
'circledcirc' => '&#x229A;',
'circleddash' => '&#x229D;',
'CircleDot' => '&#x2299;',
'circledR' => '&#x00AF;',
'circledS' => '&#xE41D;',
'circlef' => '&#x25CF;',
'circlefb' => '&#x25D2;',
'circlefl' => '&#x25D0;',
'circlefr' => '&#x25D1;',
'circleft' => '&#x25D3;',
'CircleMinus' => '&#x2296;',
'CirclePlus' => '&#x2295;',
'CircleTimes' => '&#x2297;',
'cirE' => '&#xE41B;',
'cire' => '&#x2257;',
'cirfnint' => '&#xE395;',
'cirmid' => '&#xE250;',
'cirscir' => '&#xE41C;',
'ClockwiseContourIntegral' => '&#x2232;',
'CloseCurlyDoubleQuote' => '&#x201D;',
'CloseCurlyQuote' => '&#x2019;',
'clubs' => '&#x2663;',
'clubsuit' => '&#x2663;',
'Colon' => '&#x2237;',
'colon' => '&#x003A;',
'Colone' => '&#xE30E;',
'colone' => '&#x2254;',
'coloneq' => '&#x2254;',
'comma' => '&#x002C;',
'commat' => '&#x0040;',
'comp' => '&#x2201;',
'compfn' => '&#x2218;',
'complement' => '&#x2201;',
'cong' => '&#x2245;',
'congdot' => '&#xE314;',
'Congruent' => '&#x2261;',
'Conint' => '&#x222F;',
'conint' => '&#x222E;',
'ContourIntegral' => '&#x222E;',
'Copf' => '&#x2102;',
'coprod' => '&#x2210;',
'Coproduct' => '&#x2210;',
'copy' => '&#x00A9;',
'copysr' => '&#x2117;',
'CounterClockwiseContourIntegral' => '&#x2233;',
'cross' => '&#x2612;',
'Cscr' => '&#xE4C7;',
'cscr' => '&#xE4E1;',
'csub' => '&#xE351;',
'csube' => '&#xE353;',
'csup' => '&#xE352;',
'csupe' => '&#xE354;',
'ctdot' => '&#x22EF;',
'cudarrl' => '&#xE23E;',
'cudarrr' => '&#xE400;',
'cuepr' => '&#x22DE;',
'cuesc' => '&#x22DF;',
'cularr' => '&#x21B6;',
'cularrp' => '&#xE24A;',
'Cup' => '&#x2323;',
'cup' => '&#x222A;',
'cupbrcap' => '&#xE270;',
'CupCap' => '&#x224D;',
'cupcap' => '&#xE26E;',
'cupcup' => '&#xE272;',
'cupdot' => '&#x228D;',
'cupor' => '&#xE282;',
'cups' => '&#xE274;',
'curarr' => '&#x21B7;',
'curarrm' => '&#xE249;',
'curlyeqprec' => '&#x22DE;',
'curlyeqsucc' => '&#x22DF;',
'curlyvee' => '&#x22CE;',
'curlywedge' => '&#x22CF;',
'curren' => '&#x00A4;',
'curvearrowleft' => '&#x21B6;',
'curvearrowright' => '&#x21B7;',
'cuvee' => '&#x22CE;',
'cuwed' => '&#x22CF;',
'cwconint' => '&#x2232;',
'cwint' => '&#x2231;',
'cylcty' => '&#x232D;',
'Dagger' => '&#x2021;',
'dagger' => '&#x2020;',
'daleth' => '&#x2138;',
'Darr' => '&#x21A1;',
'dArr' => '&#x21D3;',
'darr' => '&#x2193;',
'dash' => '&#x2010;',
'Dashv' => '&#xE30F;',
'dashv' => '&#x22A3;',
'dbkarow' => '&#xE207;',
'dblac' => '&#x030B;',
'ddagger' => '&#x2021;',
'ddarr' => '&#x21CA;',
'DDotrahd' => '&#xE238;',
'ddotseq' => '&#xE309;',
'deg' => '&#x00B0;',
'Del' => '&#x2207;',
'Delta' => '&#x0394;',
'delta' => '&#x03B4;',
'demptyv' => '&#xE2E7;',
'dfisht' => '&#xE24C;',
'Dfr' => '&#xE47F;',
'dfr' => '&#xE498;',
'dHar' => '&#xE227;',
'dharl' => '&#x21C3;',
'dharr' => '&#x21C2;',
'DiacriticalAcute' => '&#x0301;',
'DiacriticalDot' => '&#x0307;',
'DiacriticalDoubleAcute' => '&#x030B;',
'DiacriticalGrave' => '&#x0300;',
'DiacriticalLeftArrow' => '&#x20D6;',
'DiacriticalLeftRightArrow' => '&#x20E1;',
'DiacriticalLeftRightVector' => '&#xF505;',
'DiacriticalLeftVector' => '&#x20D0;',
'DiacriticalRightArrow' => '&#x20D7;',
'DiacriticalRightVector' => '&#x20D1;',
'DiacriticalTilde' => '&#x0303;',
'diam' => '&#x22C4;',
'diamond' => '&#x22C4;',
'diamondf' => '&#xE4FB;',
'diamondsuit' => '&#x2662;',
'diamonfb' => '&#xE4FC;',
'diamonfl' => '&#xE4FD;',
'diamonfr' => '&#xE4FE;',
'diamonft' => '&#xE4FF;',
'diams' => '&#x2662;',
'die' => '&#x0308;',
'digamma' => '&#x03DC;',
'disin' => '&#xE3A0;',
'div' => '&#x00F7;',
'divide' => '&#x00F7;',
'divideontimes' => '&#x22C7;',
'divonx' => '&#x22C7;',
'dlcorn' => '&#x231E;',
'dlcrop' => '&#x230D;',
'dollar' => '&#x0024;',
'Dopf' => '&#xE4B1;',
'Dot' => '&#x0308;',
'dot' => '&#x0307;',
'DotDot' => '&#x20DC;',
'doteq' => '&#x2250;',
'doteqdot' => '&#x2251;',
'DotEqual' => '&#x2250;',
'dotminus' => '&#x2238;',
'dotplus' => '&#x2214;',
'dotsquare' => '&#x22A1;',
'doublebarwedge' => '&#x2306;',
'DoubleContourIntegral' => '&#x222F;',
'DoubleDot' => '&#x0308;',
'DoubleDownArrow' => '&#x21D3;',
'DoubleLeftArrow' => '&#x21D0;',
'DoubleLeftRightArrow' => '&#x21D4;',
'DoubleLongLeftArrow' => '&#xE200;',
'DoubleLongLeftRightArrow' => '&#xE202;',
'DoubleLongRightArrow' => '&#xE204;',
'DoubleRightArrow' => '&#x21D2;',
'DoubleRightTee' => '&#x22A8;',
'DoubleUpArrow' => '&#x21D1;',
'DoubleUpDownArrow' => '&#x21D5;',
'DoubleVerticalBar' => '&#x2225;',
'DownArrow' => '&#x2193;',
'Downarrow' => '&#x21D3;',
'downarrow' => '&#x2193;',
'DownArrowUpArrow' => '&#xE216;',
'downdownarrows' => '&#x21CA;',
'downharpoonleft' => '&#x21C3;',
'downharpoonright' => '&#x21C2;',
'DownLeftVector' => '&#x21BD;',
'DownRightVector' => '&#x21C1;',
'DownTee' => '&#x22A4;',
'drbkarow' => '&#xE209;',
'drcorn' => '&#x231F;',
'drcrop' => '&#x230C;',
'Dscr' => '&#xE4C8;',
'dscr' => '&#xE4E2;',
'dsol' => '&#xE3A9;',
'dtdot' => '&#x22F1;',
'dtri' => '&#x25BF;',
'dtrif' => '&#x25BE;',
'duarr' => '&#xE216;',
'duhar' => '&#xE217;',
'dwangle' => '&#xE3AA;',
'dzigrarr' => '&#x21DD;',
'easter' => '&#x225B;',
'ecir' => '&#x2256;',
'ecolon' => '&#x2255;',
'eDDot' => '&#xE309;',
'eDot' => '&#x2251;',
'efDot' => '&#x2252;',
'Efr' => '&#xE480;',
'efr' => '&#xE499;',
'eg' => '&#xE328;',
'egs' => '&#x22DD;',
'egsdot' => '&#xE324;',
'el' => '&#xE327;',
'Element' => '&#x2208;',
'elinters' => '&#xE3A7;',
'ell' => '&#x2113;',
'els' => '&#x22DC;',
'elsdot' => '&#xE323;',
'empty' => '&#xE2D3;',
'emptyset' => '&#xE2D3;',
'emptyv' => '&#x2205;',
'emsp' => '&#x2003;',
'emsp13' => '&#x2004;',
'emsp14' => '&#x2005;',
'ensp' => '&#x2002;',
'Eopf' => '&#xE4B2;',
'epar' => '&#x22D5;',
'eparsl' => '&#xE384;',
'eplus' => '&#xE268;',
'epsi' => '&#x220A;',
'epsiv' => '&#x03B5;',
'eqcirc' => '&#x2256;',
'eqcolon' => '&#x2255;',
'eqsim' => '&#x2242;',
'eqslantgtr' => '&#x22DD;',
'eqslantless' => '&#x22DC;',
'equals' => '&#x003D;',
'EqualTilde' => '&#x2242;',
'equest' => '&#x225F;',
'Equilibrium' => '&#x21CC;',
'equiv' => '&#x2261;',
'equivDD' => '&#xE318;',
'eqvparsl' => '&#xE386;',
'erarr' => '&#xE236;',
'erDot' => '&#x2253;',
'Escr' => '&#xE4C9;',
'escr' => '&#xE4E3;',
'esdot' => '&#x2250;',
'Esim' => '&#xE317;',
'esim' => '&#x2242;',
'eta' => '&#x03B7;',
'excl' => '&#x0021;',
'exist' => '&#x2203;',
'Exists' => '&#x2203;',
'fallingdotseq' => '&#x2252;',
'female' => '&#x2640;',
'ffilig' => '&#xFB03;',
'fflig' => '&#xFB00;',
'ffllig' => '&#xFB04;',
'Ffr' => '&#xE481;',
'ffr' => '&#xE49A;',
'filig' => '&#xFB01;',
'fjlig' => '&#xE500;',
'flat' => '&#x266D;',
'fllig' => '&#xFB02;',
'fltns' => '&#xE381;',
'Fopf' => '&#xE4B3;',
'ForAll' => '&#x2200;',
'forall' => '&#x2200;',
'fork' => '&#x22D4;',
'forkv' => '&#xE31B;',
'fpartint' => '&#xE396;',
'frac12' => '&#x00BD;',
'frac13' => '&#x2153;',
'frac14' => '&#x00BC;',
'frac15' => '&#x2155;',
'frac16' => '&#x2159;',
'frac18' => '&#x215B;',
'frac23' => '&#x2254;',
'frac25' => '&#x2156;',
'frac34' => '&#x00BE;',
'frac35' => '&#x2157;',
'frac38' => '&#x215C;',
'frac45' => '&#x2158;',
'frac56' => '&#x215A;',
'frac58' => '&#x215D;',
'frac78' => '&#x215E;',
'frown' => '&#x2322;',
'Fscr' => '&#xE4CA;',
'fscr' => '&#xE4E4;',
'Gamma' => '&#x0393;',
'gamma' => '&#x03B3;',
'Gammad' => '&#x03DC;',
'gammad' => '&#x03DC;',
'gap' => '&#x2273;',
'gE' => '&#x2267;',
'ge' => '&#x2265;',
'gEl' => '&#x22DB;',
'gel' => '&#x22DB;',
'geq' => '&#x2265;',
'geqq' => '&#x2267;',
'geqslant' => '&#xE421;',
'ges' => '&#xE421;',
'gescc' => '&#xE358;',
'gesdot' => '&#xE31E;',
'gesdoto' => '&#xE320;',
'gesdotol' => '&#xE322;',
'gesl' => '&#xE32C;',
'gesles' => '&#xE332;',
'Gfr' => '&#xE482;',
'gfr' => '&#xE49B;',
'Gg' => '&#x22D9;',
'gg' => '&#x226B;',
'ggg' => '&#x22D9;',
'gimel' => '&#x2137;',
'gl' => '&#x2277;',
'gla' => '&#xE330;',
'glE' => '&#xE32E;',
'glj' => '&#xE32F;',
'gnap' => '&#xE411;',
'gnapprox' => '&#xE411;',
'gnE' => '&#x2269;',
'gne' => '&#x2269;',
'gneq' => '&#x2269;',
'gneqq' => '&#x2269;',
'gnsim' => '&#x22E7;',
'Gopf' => '&#xE4B4;',
'grave' => '&#x0300;',
'GreaterEqual' => '&#x2265;',
'GreaterEqualLess' => '&#x22DB;',
'GreaterFullEqual' => '&#x2267;',
'GreaterLess' => '&#x2277;',
'GreaterSlantEqual' => '&#xE421;',
'GreaterTilde' => '&#x2273;',
'Gscr' => '&#xE4CB;',
'gscr' => '&#xE4E5;',
'gsim' => '&#x2273;',
'gsime' => '&#xE334;',
'gsiml' => '&#xE336;',
'Gt' => '&#x226B;',
'gt' => '&#x003E;',
'gtcc' => '&#xE356;',
'gtcir' => '&#xE326;',
'gtdot' => '&#x22D7;',
'gtlPar' => '&#xE296;',
'gtquest' => '&#xE32A;',
'gtrapprox' => '&#x2273;',
'gtrarr' => '&#xE35F;',
'gtrdot' => '&#x22D7;',
'gtreqless' => '&#x22DB;',
'gtreqqless' => '&#x22DB;',
'gtrless' => '&#x2277;',
'gtrsim' => '&#x2273;',
'gvertneqq' => '&#xE2A1;',
'gvnE' => '&#xE2A1;',
'Hacek' => '&#x030C;',
'hairsp' => '&#x200A;',
'half' => '&#x00BD;',
'hamilt' => '&#x210B;',
'hArr' => '&#x21D4;',
'harr' => '&#x2194;',
'harrcir' => '&#xE240;',
'harrw' => '&#x21AD;',
'Hat' => '&#x0302;',
'hbar' => '&#xE2D5;',
'hbenzen' => '&#xE44F;',
'hbenzena' => '&#xE43D;',
'hbenzenb' => '&#xE43E;',
'hbenzenc' => '&#xE43F;',
'hbenzend' => '&#xE440;',
'hbenzene' => '&#xE441;',
'hbenzenf' => '&#xE442;',
'hbenzeng' => '&#xE443;',
'hbenzenh' => '&#xE444;',
'hbenzeni' => '&#xE445;',
'hbenzenj' => '&#xE446;',
'hbenzenk' => '&#xE447;',
'hbenzenl' => '&#xE448;',
'hbenzenm' => '&#xE449;',
'hbenzenn' => '&#xE44A;',
'hbenzeno' => '&#xE44B;',
'hbenzenp' => '&#xE44C;',
'hbenzenq' => '&#xE44D;',
'hbenzenr' => '&#xE44E;',
'hearts' => '&#x2661;',
'heartsuit' => '&#x2661;',
'hellip' => '&#x2026;',
'hercon' => '&#x22B9;',
'Hfr' => '&#xE483;',
'hfr' => '&#xE49C;',
'hksearow' => '&#xE20B;',
'hkswarow' => '&#xE20A;',
'hoarr' => '&#xE243;',
'homtht' => '&#x223B;',
'hookleftarrow' => '&#x21A9;',
'hookrightarrow' => '&#x21AA;',
'Hopf' => '&#xE4B5;',
'horbar' => '&#x2015;',
'Hscr' => '&#xE4CC;',
'hscr' => '&#xE4E6;',
'hslash' => '&#x210F;',
'HumpDownHump' => '&#x224E;',
'HumpEqual' => '&#x224F;',
'hybull' => '&#x2043;',
'hyphen' => '&#xE4F8;',
'iexcl' => '&#x00A1;',
'iff' => '&#xE365;',
'Ifr' => '&#xE484;',
'ifr' => '&#xE49D;',
'iiiint' => '&#xE378;',
'iiint' => '&#x222D;',
'iinfin' => '&#xE372;',
'iiota' => '&#x2129;',
'Im' => '&#x2111;',
'image' => '&#x2111;',
'imath' => '&#x0131;',
'imof' => '&#x22B7;',
'imped' => '&#xE50B;',
'Implies' => '&#x21D2;',
'in' => '&#x220A;',
'incare' => '&#x2105;',
'infin' => '&#x221E;',
'infintie' => '&#xE50C;',
'Int' => '&#x222C;',
'int' => '&#x222B;',
'intcal' => '&#x22BA;',
'Integral' => '&#x222B;',
'intercal' => '&#x22BA;',
'Intersection' => '&#x22C2;',
'intlarhk' => '&#xE39A;',
'intprod' => '&#xE259;',
'Iopf' => '&#xE4B6;',
'iota' => '&#x03B9;',
'iprod' => '&#xE259;',
'iquest' => '&#x00BF;',
'Iscr' => '&#xE4CD;',
'iscr' => '&#xE4E7;',
'isin' => '&#x220A;',
'isindot' => '&#xE39C;',
'isinE' => '&#xE39E;',
'isins' => '&#xE3A4;',
'isinsv' => '&#xE3A2;',
'isinv' => '&#x2208;',
'Jfr' => '&#xE485;',
'jfr' => '&#xE49E;',
'jmath' => '&#xE2D4;',
'Jopf' => '&#xE4B7;',
'Jscr' => '&#xE4CE;',
'jscr' => '&#xE4E8;',
'kappa' => '&#x03BA;',
'kappav' => '&#x03F0;',
'Kfr' => '&#xE486;',
'kfr' => '&#xE49F;',
'Kopf' => '&#xE4B8;',
'Kscr' => '&#xE4CF;',
'kscr' => '&#xE4E9;',
'lAarr' => '&#x21DA;',
'laemptyv' => '&#xE2EA;',
'lagran' => '&#x2112;',
'Lambda' => '&#x039B;',
'lambda' => '&#x03BB;',
'Lang' => '&#x300A;',
'lang' => '&#x3008;',
'langd' => '&#xE297;',
'langle' => '&#x3008;',
'lap' => '&#x2272;',
'laquo' => '&#x00AB;',
'Larr' => '&#x219E;',
'lArr' => '&#x21D0;',
'larr' => '&#x2190;',
'larrbfs' => '&#xE220;',
'larrfs' => '&#xE222;',
'larrhk' => '&#x21A9;',
'larrlp' => '&#x21AB;',
'larrpl' => '&#xE23F;',
'larrsim' => '&#xE24E;',
'larrtl' => '&#x21A2;',
'lat' => '&#xE33A;',
'lAtail' => '&#xE23D;',
'latail' => '&#xE23C;',
'late' => '&#xE33C;',
'lates' => '&#xE33E;',
'lBarr' => '&#xE206;',
'lbarr' => '&#xE402;',
'lbbrk' => '&#x3014;',
'lbrace' => '&#x007B;',
'lbrack' => '&#x005B;',
'lbrke' => '&#xE299;',
'lbrksld' => '&#xE29D;',
'lbrkslu' => '&#xE29B;',
'lceil' => '&#x2308;',
'lcub' => '&#x007B;',
'ldca' => '&#xE21A;',
'ldquo' => '&#x201C;',
'ldquor' => '&#x201E;',
'ldrdhar' => '&#xE22C;',
'ldrushar' => '&#xE228;',
'ldsh' => '&#x21B2;',
'lE' => '&#x2266;',
'le' => '&#x2264;',
'LeftAngleBracket' => '&#x3008;',
'LeftArrow' => '&#x2190;',
'Leftarrow' => '&#x21D0;',
'leftarrow' => '&#x2190;',
'LeftArrowRightArrow' => '&#x21C6;',
'leftarrowtail' => '&#x21A2;',
'LeftCeiling' => '&#x2308;',
'LeftDownVector' => '&#x21C3;',
'LeftFloor' => '&#x230A;',
'leftharpoondown' => '&#x21BD;',
'leftharpoonup' => '&#x21BC;',
'leftleftarrows' => '&#x21C7;',
'LeftRightArrow' => '&#x2194;',
'Leftrightarrow' => '&#x21D4;',
'leftrightarrow' => '&#x2194;',
'leftrightarrows' => '&#x21C6;',
'leftrightharpoons' => '&#x21CB;',
'leftrightsquigarrow' => '&#x21AD;',
'LeftTee' => '&#x22A3;',
'leftthreetimes' => '&#x22CB;',
'LeftTriangle' => '&#x22B2;',
'LeftTriangleEqual' => '&#x22B4;',
'LeftUpVector' => '&#x21BF;',
'LeftVector' => '&#x21BC;',
'lEg' => '&#x22DA;',
'leg' => '&#x22DA;',
'leq' => '&#x2264;',
'leqq' => '&#x2266;',
'leqslant' => '&#xE425;',
'les' => '&#xE425;',
'lescc' => '&#xE357;',
'lesdot' => '&#xE31D;',
'lesdoto' => '&#xE31F;',
'lesdotor' => '&#xE321;',
'lesg' => '&#xE32B;',
'lesges' => '&#xE331;',
'lessapprox' => '&#x2272;',
'lessdot' => '&#x22D6;',
'lesseqgtr' => '&#x22DA;',
'lesseqqgtr' => '&#x22DA;',
'LessEqualGreater' => '&#x22DA;',
'LessFullEqual' => '&#x2266;',
'LessGreater' => '&#x2276;',
'lessgtr' => '&#x2276;',
'lesssim' => '&#x2272;',
'LessSlantEqual' => '&#xE425;',
'LessTilde' => '&#x2272;',
'lfisht' => '&#xE214;',
'lfloor' => '&#x230A;',
'Lfr' => '&#xE487;',
'lfr' => '&#xE4A0;',
'lg' => '&#x2276;',
'lgE' => '&#xE32D;',
'lHar' => '&#xE225;',
'lhard' => '&#x21BD;',
'lharu' => '&#x21BC;',
'lharul' => '&#xE22E;',
'lhblk' => '&#x2584;',
'Ll' => '&#x22D8;',
'll' => '&#x226A;',
'llarr' => '&#x21C7;',
'llcorner' => '&#x231E;',
'Lleftarrow' => '&#x21DA;',
'llhard' => '&#xE231;',
'lltri' => '&#xE2E5;',
'lmoust' => '&#xE294;',
'lmoustache' => '&#xE294;',
'lnap' => '&#xE2A2;',
'lnapprox' => '&#xE2A2;',
'lnE' => '&#x2268;',
'lne' => '&#x2268;',
'lneq' => '&#x2268;',
'lneqq' => '&#x2268;',
'lnsim' => '&#x22E6;',
'loang' => '&#x3018;',
'loarr' => '&#xE242;',
'lobrk' => '&#x301A;',
'LongLeftArrow' => '&#xE201;',
'Longleftarrow' => '&#xE200;',
'longleftarrow' => '&#xE201;',
'LongLeftRightArrow' => '&#xE203;',
'Longleftrightarrow' => '&#xE202;',
'longleftrightarrow' => '&#xE203;',
'longmapsto' => '&#xE208;',
'LongRightArrow' => '&#xE205;',
'Longrightarrow' => '&#xE204;',
'longrightarrow' => '&#xE205;',
'looparrowleft' => '&#x21AB;',
'looparrowright' => '&#x21AC;',
'lopar' => '&#xE379;',
'Lopf' => '&#xE4B9;',
'loplus' => '&#xE25C;',
'lotimes' => '&#xE25E;',
'lowast' => '&#x2217;',
'lowbar' => '&#x005F;',
'LowerLeftArrow' => '&#x2199;',
'LowerRightArrow' => '&#x2198;',
'loz' => '&#x25CA;',
'lozenge' => '&#x25CA;',
'lozf' => '&#xE501;',
'lpar' => '&#x0028;',
'lparlt' => '&#xE292;',
'lrarr' => '&#x21C6;',
'lrcorner' => '&#x231F;',
'lrhar' => '&#x21CB;',
'lrhard' => '&#xE22F;',
'lrtri' => '&#xE2E3;',
'Lscr' => '&#xE4D0;',
'lscr' => '&#xE4EA;',
'Lsh' => '&#x21B0;',
'lsh' => '&#x21B0;',
'lsim' => '&#x2272;',
'lsime' => '&#xE333;',
'lsimg' => '&#xE335;',
'lsqb' => '&#x005B;',
'lsquo' => '&#x2018;',
'lsquor' => '&#x201A;',
'Lt' => '&#x226A;',
'lt' => '&#x003C;',
'ltcc' => '&#xE355;',
'ltcir' => '&#xE325;',
'ltdot' => '&#x22D6;',
'lthree' => '&#x22CB;',
'ltimes' => '&#x22C9;',
'ltlarr' => '&#xE35E;',
'ltquest' => '&#xE329;',
'ltri' => '&#x25C3;',
'ltrie' => '&#x22B4;',
'ltrif' => '&#x25C2;',
'ltrPar' => '&#xE295;',
'lurdshar' => '&#xE229;',
'luruhar' => '&#xE22B;',
'lvertneqq' => '&#xE2A4;',
'lvnE' => '&#xE2A4;',
'macr' => '&#x0304;',
'male' => '&#x2642;',
'malt' => '&#x2720;',
'maltese' => '&#x2720;',
'Map' => '&#xE212;',
'map' => '&#x21A6;',
'mapsto' => '&#x21A6;',
'marker' => '&#xE502;',
'mcomma' => '&#xE31A;',
'mdash' => '&#x2014;',
'mDDot' => '&#x223A;',
'measuredangle' => '&#x2221;',
'Mfr' => '&#xE488;',
'mfr' => '&#xE4A1;',
'mho' => '&#x2127;',
'micro' => '&#x00B5;',
'mid' => '&#x2223;',
'midast' => '&#x2217;',
'midcir' => '&#xE20F;',
'middot' => '&#x00B7;',
'minus' => '&#x2212;',
'minusb' => '&#x229F;',
'minusd' => '&#x2238;',
'minusdu' => '&#xE25B;',
'MinusPlus' => '&#x2213;',
'mlcp' => '&#xE30A;',
'mldr' => '&#xE503;',
'mnplus' => '&#x2213;',
'models' => '&#x22A7;',
'Mopf' => '&#xE4BA;',
'mp' => '&#x2213;',
'Mscr' => '&#xE4D1;',
'mscr' => '&#xE4EB;',
'mstpos' => '&#x223E;',
'mu' => '&#x03BC;',
'multimap' => '&#x22B8;',
'mumap' => '&#x22B8;',
'nabla' => '&#x2207;',
'nang' => '&#xE2D8;',
'nap' => '&#x2249;',
'napE' => '&#xE2C7;',
'napid' => '&#xE2BC;',
'napprox' => '&#x2249;',
'natur' => '&#x266E;',
'natural' => '&#x266E;',
'nbsp' => '&#x00A0;',
'ncap' => '&#xE284;',
'ncong' => '&#x2247;',
'ncongdot' => '&#xE2C5;',
'ncup' => '&#xE283;',
'ndash' => '&#x2013;',
'ne' => '&#x2260;',
'nearhk' => '&#xE20D;',
'neArr' => '&#x21D7;',
'nearr' => '&#x2197;',
'nearrow' => '&#x2197;',
'nedot' => '&#xE38A;',
'nequiv' => '&#x2262;',
'nesear' => '&#xE20E;',
'NestedGreaterGreater' => '&#x226B;',
'NestedLessLess' => '&#x226A;',
'nexist' => '&#x2204;',
'nexists' => '&#x2204;',
'Nfr' => '&#xE489;',
'nfr' => '&#xE4A2;',
'ngE' => '&#x2271;',
'nge' => '&#xE2A6;',
'ngeq' => '&#xE2A6;',
'ngeqq' => '&#x2271;',
'ngeqslant' => '&#x2271;',
'nges' => '&#x2271;',
'nGg' => '&#xE2CE;',
'ngsim' => '&#x2275;',
'nGt' => '&#xE2CA;',
'ngt' => '&#x226F;',
'ngtr' => '&#x226F;',
'nGtv' => '&#xE2CC;',
'nhArr' => '&#x21CE;',
'nharr' => '&#x21AE;',
'nhpar' => '&#xE38D;',
'ni' => '&#x220D;',
'nis' => '&#xE3A5;',
'nisd' => '&#xE3A1;',
'niv' => '&#x220B;',
'nlArr' => '&#x21CD;',
'nlarr' => '&#x219A;',
'nldr' => '&#x2025;',
'nlE' => '&#x2270;',
'nle' => '&#xE2A7;',
'nLeftarrow' => '&#x21CD;',
'nleftarrow' => '&#x219A;',
'nLeftrightarrow' => '&#x21CE;',
'nleftrightarrow' => '&#x21AE;',
'nleq' => '&#xE2A7;',
'nleqq' => '&#x2270;',
'nleqslant' => '&#x2270;',
'nles' => '&#x2270;',
'nless' => '&#x226E;',
'nLl' => '&#xE2CD;',
'nlsim' => '&#x2274;',
'nLt' => '&#xE2C9;',
'nlt' => '&#x226E;',
'nltri' => '&#x22EA;',
'nltrie' => '&#x22EC;',
'nLtv' => '&#xE2CB;',
'nmid' => '&#x2224;',
'Nopf' => '&#x2115;',
'Not' => '&#xE3AC;',
'not' => '&#x00AC;',
'NotCongruent' => '&#x2262;',
'NotDoubleVerticalBar' => '&#x2226;',
'NotElement' => '&#x2209;',
'NotEqual' => '&#x2260;',
'NotExists' => '&#x2204;',
'NotGreater' => '&#x226F;',
'NotGreaterEqual' => '&#xE2A6;',
'NotGreaterFullEqual' => '&#x2270;',
'NotGreaterGreater' => '&#xE2CC;',
'NotGreaterLess' => '&#x2279;',
'NotGreaterSlantEqual' => '&#x2271;',
'NotGreaterTilde' => '&#x2275;',
'notin' => '&#x2209;',
'notindot' => '&#xE39D;',
'notinE' => '&#xE50D;',
'notinva' => '&#xE370;',
'notinvb' => '&#xE37B;',
'notinvc' => '&#xE37C;',
'NotLeftTriangle' => '&#x22EA;',
'NotLeftTriangleEqual' => '&#x22EC;',
'NotLess' => '&#x226E;',
'NotLessEqual' => '&#xE2A7;',
'NotLessFullEqual' => '&#x2270;',
'NotLessGreater' => '&#x2278;',
'NotLessLess' => '&#xE2CB;',
'NotLessSlantEqual' => '&#x2270;',
'NotLessTilde' => '&#x2274;',
'notni' => '&#x220C;',
'notniva' => '&#x220C;',
'notnivb' => '&#xE37D;',
'notnivc' => '&#xE37E;',
'NotPrecedes' => '&#x2280;',
'NotPrecedesEqual' => '&#xE412;',
'NotPrecedesSlantEqual' => '&#x22E0;',
'NotReverseElement' => '&#x220C;',
'NotRightTriangle' => '&#x22EB;',
'NotRightTriangleEqual' => '&#x22ED;',
'NotSquareSubsetEqual' => '&#x22E2;',
'NotSquareSupersetEqual' => '&#x22E3;',
'NotSubset' => '&#x2284;',
'NotSucceeds' => '&#x2281;',
'NotSucceedsEqual' => '&#xE413;',
'NotSucceedsSlantEqual' => '&#x22E1;',
'NotSuperset' => '&#x2285;',
'NotTilde' => '&#x2241;',
'NotTildeEqual' => '&#x2244;',
'NotTildeFullEqual' => '&#x2247;',
'NotTildeTilde' => '&#x2249;',
'NotVerticalBar' => '&#x2224;',
'npar' => '&#x2226;',
'nparallel' => '&#x2226;',
'nparsl' => '&#xE389;',
'npart' => '&#xE390;',
'npolint' => '&#xE399;',
'npr' => '&#x2280;',
'nprcue' => '&#x22E0;',
'npre' => '&#xE412;',
'nprec' => '&#x2280;',
'npreceq' => '&#xE412;',
'nrArr' => '&#x21CF;',
'nrarr' => '&#x219B;',
'nrarrc' => '&#xE21D;',
'nrarrw' => '&#xE21B;',
'nRightarrow' => '&#x21CF;',
'nrightarrow' => '&#x219B;',
'nrtri' => '&#x22EB;',
'nrtrie' => '&#x22ED;',
'nsc' => '&#x2281;',
'nsccue' => '&#x22E1;',
'nsce' => '&#xE413;',
'Nscr' => '&#xE4D2;',
'nscr' => '&#xE4EC;',
'nshortmid' => '&#xE2AA;',
'nshortparallel' => '&#xE2AB;',
'nsim' => '&#x2241;',
'nsime' => '&#x2244;',
'nsimeq' => '&#x2244;',
'nsmid' => '&#xE2AA;',
'nspar' => '&#xE2AB;',
'nsqsube' => '&#x22E2;',
'nsqsupe' => '&#x22E3;',
'nsub' => '&#x2284;',
'nsubE' => '&#x2288;',
'nsube' => '&#x2288;',
'nsubset' => '&#x2284;',
'nsubseteq' => '&#x2288;',
'nsubseteqq' => '&#x2288;',
'nsucc' => '&#x2281;',
'nsucceq' => '&#xE413;',
'nsup' => '&#x2285;',
'nsupE' => '&#x2289;',
'nsupe' => '&#x2289;',
'nsupset' => '&#x2285;',
'nsupseteq' => '&#x2289;',
'nsupseteqq' => '&#x2289;',
'ntgl' => '&#x2279;',
'ntlg' => '&#x2278;',
'ntriangleleft' => '&#x22EA;',
'ntrianglelefteq' => '&#x22EC;',
'ntriangleright' => '&#x22EB;',
'ntrianglerighteq' => '&#x22ED;',
'ntvgl' => '&#x2279;',
'ntvlg' => '&#x2278;',
'nu' => '&#x03BD;',
'num' => '&#x0023;',
'numsp' => '&#x2007;',
'nvap' => '&#xE2C6;',
'nVDash' => '&#x22AF;',
'nVdash' => '&#x22AE;',
'nvDash' => '&#x22AD;',
'nvdash' => '&#x22AC;',
'nvge' => '&#x2271;',
'nvgt' => '&#x226F;',
'nvhArr*' => '&#x21CE;',
'nvinfin' => '&#xE38E;',
'nvlArr' => '&#x21CD;',
'nvle' => '&#x2270;',
'nvlt' => '&#x226E;',
'nvltrie' => '&#xE2D0;',
'nvrArr' => '&#x21CF;',
'nvrtrie' => '&#xE2CF;',
'nvsim' => '&#xE415;',
'nwarhk' => '&#xE20C;',
'nwArr' => '&#x21D6;',
'nwarr' => '&#x2196;',
'nwarrow' => '&#x2196;',
'nwnear' => '&#xE211;',
'oast' => '&#x229B;',
'ocir' => '&#x229A;',
'odash' => '&#x229D;',
'odiv' => '&#xE285;',
'odot' => '&#x2299;',
'odsold' => '&#xE286;',
'ofcir' => '&#xE287;',
'Ofr' => '&#xE48A;',
'ofr' => '&#xE4A3;',
'ogon' => '&#x0328;',
'ogt' => '&#xE289;',
'ohbar' => '&#xE260;',
'ohm' => '&#x2126;',
'oint' => '&#x222E;',
'olarr' => '&#x21BA;',
'olcir' => '&#xE409;',
'olcross' => '&#xE3A8;',
'olt' => '&#xE288;',
'Omega' => '&#x03A9;',
'omega' => '&#x03C9;',
'omicron' => '&#x03BE;',
'omid' => '&#xE40A;',
'ominus' => '&#x2296;',
'Oopf' => '&#xE4BC;',
'opar' => '&#xE28A;',
'OpenCurlyDoubleQuote' => '&#x201C;',
'OpenCurlyQuote' => '&#x2018;',
'operp' => '&#xE28B;',
'oplus' => '&#x2295;',
'Or' => '&#xE375;',
'or' => '&#x2228;',
'orarr' => '&#x21BB;',
'ord' => '&#xE393;',
'order' => '&#x2134;',
'ordf' => '&#x00AA;',
'ordm' => '&#x00BA;',
'origof' => '&#x22B6;',
'oror' => '&#xE50E;',
'orslope' => '&#xE3AE;',
'orv' => '&#xE392;',
'oS' => '&#xE41D;',
'Oscr' => '&#xE4D3;',
'oscr' => '&#xE4ED;',
'oslash' => '&#x2298;',
'osol' => '&#x2298;',
'Otimes' => '&#xE28C;',
'otimes' => '&#x2297;',
'otimesas' => '&#xE28D;',
'ovbar' => '&#xE40B;',
'OverLine' => '&#x0305;',
'par' => '&#x2225;',
'para' => '&#x00B6;',
'parallel' => '&#x2225;',
'parsim' => '&#xE2C8;',
'parsl' => '&#xE382;',
'part' => '&#x2202;',
'PartialD' => '&#x2202;',
'percnt' => '&#x0025;',
'period' => '&#x002E;',
'permil' => '&#x2030;',
'perp' => '&#x22A5;',
'pertenk' => '&#x2031;',
'Pfr' => '&#xE48B;',
'pfr' => '&#xE4A4;',
'Phi' => '&#x03A6;',
'phi' => '&#x03C6;',
'phiv' => '&#x03D5;',
'phmmat' => '&#x2133;',
'phone' => '&#x260E;',
'Pi' => '&#x03A0;',
'pi' => '&#x03C0;',
'pitchfork' => '&#x22D4;',
'piv' => '&#x03D6;',
'plank' => '&#xE2D5;',
'plankv' => '&#x210F;',
'plus' => '&#x002B;',
'plusacir' => '&#xE26A;',
'plusb' => '&#x229E;',
'pluscir' => '&#xE266;',
'plusdo' => '&#x2214;',
'plusdu' => '&#xE25A;',
'pluse' => '&#xE267;',
'PlusMinus' => '&#x00B1;',
'plusmn' => '&#x00B1;',
'plussim' => '&#xE26C;',
'plustwo' => '&#xE269;',
'pm' => '&#x00B1;',
'pointint' => '&#xE376;',
'Popf' => '&#x2119;',
'pound' => '&#x00A3;',
'Pr' => '&#xE35C;',
'pr' => '&#x227A;',
'prap' => '&#x227E;',
'prcue' => '&#x227C;',
'prE' => '&#x227C;',
'pre' => '&#x227C;',
'prec' => '&#x227A;',
'precapprox' => '&#x227E;',
'preccurlyeq' => '&#x227C;',
'Precedes' => '&#x227A;',
'PrecedesEqual' => '&#x227C;',
'PrecedesSlantEqual' => '&#x227C;',
'PrecedesTilde' => '&#x227E;',
'preceq' => '&#x227C;',
'precnapprox' => '&#x22E8;',
'precneqq' => '&#xE2B3;',
'precnsim' => '&#x22E8;',
'precsim' => '&#x227E;',
'Prime' => '&#x2033;',
'prime' => '&#x2032;',
'prnap' => '&#x22E8;',
'prnE' => '&#xE2B3;',
'prnsim' => '&#x22E8;',
'profalar' => '&#x232E;',
'profline' => '&#x2312;',
'profsurf' => '&#x2313;',
'prop' => '&#x221D;',
'Proportion' => '&#x2237;',
'Proportional' => '&#x221D;',
'propto' => '&#x221D;',
'prsim' => '&#x227E;',
'prurel' => '&#x22B0;',
'Pscr' => '&#xE4D4;',
'pscr' => '&#xE4EE;',
'Psi' => '&#x03A8;',
'psi' => '&#x03C8;',
'puncsp' => '&#x2008;',
'Qfr' => '&#xE48C;',
'qfr' => '&#xE4A5;',
'qint' => '&#xE378;',
'Qopf' => '&#x211A;',
'qprime' => '&#xE371;',
'Qscr' => '&#xE4D5;',
'qscr' => '&#xE4EF;',
'quatint' => '&#xE377;',
'quest' => '&#x003F;',
'questeq' => '&#x225F;',
'quot' => '&#x0022;',
'rAarr' => '&#x21DB;',
'race' => '&#xE40C;',
'radic' => '&#x221A;',
'raemptyv' => '&#xE2E9;',
'Rang' => '&#x300B;',
'rang' => '&#x3009;',
'rangd' => '&#xE298;',
'range' => '&#xE2D7;',
'rangle' => '&#x3009;',
'raquo' => '&#x00BB;',
'Rarr' => '&#x21A0;',
'rArr' => '&#x21D2;',
'rarr' => '&#x2192;',
'rarrap' => '&#xE235;',
'rarrbfs' => '&#xE221;',
'rarrc' => '&#xE21C;',
'rarrfs' => '&#xE223;',
'rarrhk' => '&#x21AA;',
'rarrlp' => '&#x21AC;',
'rarrpl' => '&#xE21E;',
'rarrsim' => '&#xE24D;',
'Rarrtl' => '&#xE239;',
'rarrtl' => '&#x21A3;',
'rarrw' => '&#x219D;',
'rAtail' => '&#xE23B;',
'ratail' => '&#x21A3;',
'ratio' => '&#x2236;',
'RBarr' => '&#xE209;',
'rBarr' => '&#xE207;',
'rbarr' => '&#xE405;',
'rbbrk' => '&#x3015;',
'rbrace' => '&#x007D;',
'rbrack' => '&#x005D;',
'rbrke' => '&#xE29A;',
'rbrksld' => '&#xE29C;',
'rbrkslu' => '&#xE29E;',
'rceil' => '&#x2309;',
'rcub' => '&#x007D;',
'rdca' => '&#xE219;',
'rdldhar' => '&#xE22D;',
'rdquo' => '&#x201D;',
'rdquor' => '&#x201B;',
'rdsh' => '&#x21B3;',
'Re' => '&#x211C;',
'real' => '&#x211C;',
'rect' => '&#xE504;',
'reg' => '&#x00AF;',
'ReverseElement' => '&#x220B;',
'ReverseEquilibrium' => '&#x21CB;',
'ReverseUpEquilibrium' => '&#xE217;',
'rfisht' => '&#xE215;',
'rfloor' => '&#x230B;',
'Rfr' => '&#xE48D;',
'rfr' => '&#xE4A6;',
'rHar' => '&#xE224;',
'rhard' => '&#x21C1;',
'rharu' => '&#x21C0;',
'rharul' => '&#xE230;',
'rho' => '&#x03C1;',
'rhov' => '&#x03F1;',
'RightAngleBracket' => '&#x3009;',
'RightArrow' => '&#x2192;',
'Rightarrow' => '&#x21D2;',
'rightarrow' => '&#x2192;',
'RightArrowLeftArrow' => '&#x21C4;',
'rightarrowtail' => '&#x21A3;',
'RightCeiling' => '&#x2309;',
'RightDownVector' => '&#x21C2;',
'RightFloor' => '&#x230B;',
'rightharpoondown' => '&#x21C1;',
'rightharpoonup' => '&#x21C0;',
'rightleftarrows' => '&#x21C4;',
'rightleftharpoons' => '&#x21CC;',
'rightrightarrows' => '&#x21C9;',
'rightsquigarrow' => '&#x219D;',
'RightTee' => '&#x22A2;',
'RightTeeArrow' => '&#x21A6;',
'rightthreetimes' => '&#x22CC;',
'RightTriangle' => '&#x22B3;',
'RightTriangleEqual' => '&#x22B5;',
'RightUpVector' => '&#x21BE;',
'RightVector' => '&#x21C0;',
'ring' => '&#x030A;',
'risingdotseq' => '&#x2253;',
'rlarr' => '&#x21C4;',
'rlhar' => '&#x21CC;',
'rmoust' => '&#xE293;',
'rmoustache' => '&#xE293;',
'rnmid' => '&#xE2D1;',
'roang' => '&#x3019;',
'roarr' => '&#xE241;',
'robrk' => '&#x301B;',
'ropar' => '&#xE37A;',
'Ropf' => '&#x211D;',
'roplus' => '&#xE25D;',
'rotimes' => '&#xE40D;',
'rpar' => '&#x0029;',
'rpargt' => '&#xE291;',
'rppolint' => '&#xE397;',
'rrarr' => '&#x21C9;',
'Rrightarrow' => '&#x21DB;',
'Rscr' => '&#xE4D6;',
'rscr' => '&#x211B;',
'Rsh' => '&#x21B1;',
'rsh' => '&#x21B1;',
'rsqb' => '&#x005D;',
'rsquo' => '&#x2019;',
'rsquor' => '&#x201F;',
'rthree' => '&#x22CC;',
'rtimes' => '&#x22CA;',
'rtri' => '&#x25B9;',
'rtrie' => '&#x22B5;',
'rtrif' => '&#x25B8;',
'rtriltri' => '&#xE359;',
'ruluhar' => '&#xE22A;',
'rx' => '&#x211E;',
'Sc' => '&#xE35D;',
'sc' => '&#x227B;',
'scap' => '&#x227F;',
'sccue' => '&#x227D;',
'scE' => '&#x227E;',
'sce' => '&#x227D;',
'scnap' => '&#x22E9;',
'scnE' => '&#xE2B5;',
'scnsim' => '&#x22E9;',
'scpolint' => '&#xE398;',
'scsim' => '&#x227F;',
'sdot' => '&#x22C5;',
'sdotb' => '&#x22A1;',
'sdote' => '&#xE319;',
'searhk' => '&#xE20B;',
'seArr' => '&#x21D8;',
'searr' => '&#x2198;',
'searrow' => '&#x2198;',
'sect' => '&#x00A7;',
'semi' => '&#x003B;',
'seswar' => '&#xE406;',
'setminus' => '&#x2216;',
'setmn' => '&#x2216;',
'sext' => '&#xE505;',
'Sfr' => '&#xE48E;',
'sfr' => '&#xE4A7;',
'sfrown' => '&#xE426;',
'sharp' => '&#x266F;',
'ShortLeftArrow' => '&#xE233;',
'shortmid' => '&#xE301;',
'shortparallel' => '&#xE302;',
'ShortRightArrow' => '&#xE232;',
'shy' => '&#x00AD;',
'Sigma' => '&#x03A3;',
'sigma' => '&#x03C3;',
'sigmav' => '&#x03C2;',
'sim' => '&#x223C;',
'simdot' => '&#xE38B;',
'sime' => '&#x2243;',
'simeq' => '&#x2243;',
'simg' => '&#xE30C;',
'simgE' => '&#xE338;',
'siml' => '&#xE30B;',
'simlE' => '&#xE337;',
'simne' => '&#x2246;',
'simplus' => '&#xE26B;',
'simrarr' => '&#xE234;',
'slarr' => '&#xE233;',
'SmallCircle' => '&#x2218;',
'smallfrown' => '&#xE426;',
'smallsetminus' => '&#xE844;',
'smallsmile' => '&#xE303;',
'smashp' => '&#xE264;',
'smeparsl' => '&#xE385;',
'smid' => '&#xE301;',
'smile' => '&#x2323;',
'smt' => '&#xE339;',
'smte' => '&#xE33B;',
'smtes' => '&#xE33D;',
'sol' => '&#x002F;',
'solb' => '&#xE27F;',
'solbar' => '&#xE416;',
'Sopf' => '&#xE4BD;',
'spades' => '&#x2660;',
'spadesuit' => '&#x2660;',
'spar' => '&#xE302;',
'sqcap' => '&#x2293;',
'sqcaps' => '&#xE277;',
'sqcup' => '&#x2294;',
'sqcups' => '&#xE276;',
'Sqrt' => '&#x221A;',
'sqsub' => '&#x228F;',
'sqsube' => '&#x2291;',
'sqsubset' => '&#x228F;',
'sqsubseteq' => '&#x2291;',
'sqsup' => '&#x2290;',
'sqsupe' => '&#x2292;',
'sqsupset' => '&#x2290;',
'sqsupseteq' => '&#x2292;',
'squ' => '&#x25A1;',
'square' => '&#x25A1;',
'SquareIntersection' => '&#x2293;',
'SquareSubset' => '&#x228F;',
'SquareSubsetEqual' => '&#x2291;',
'SquareSuperset' => '&#x2290;',
'SquareSupersetEqual' => '&#x2292;',
'SquareUnion' => '&#x2294;',
'squarf' => '&#x25A0;',
'squarfb' => '&#xE507;',
'squarfbl' => '&#xE506;',
'squarfbr' => '&#x25EA;',
'squarfl' => '&#x25E7;',
'squarfr' => '&#x25E8;',
'squarft' => '&#xE509;',
'squarftl' => '&#x25E9;',
'squarftr' => '&#xE508;',
'squf' => '&#x25AA;',
'srarr' => '&#xE232;',
'Sscr' => '&#xE4D7;',
'sscr' => '&#xE4F0;',
'ssetmn' => '&#xE844;',
'ssmile' => '&#xE303;',
'sstarf' => '&#x22C6;',
'Star' => '&#x22C6;',
'star' => '&#x22C6;',
'starf' => '&#x2605;',
'straightepsilon' => '&#x220A;',
'straightphi' => '&#x03C6;',
'strns' => '&#xE380;',
'Sub' => '&#x22D0;',
'sub' => '&#x2282;',
'subdot' => '&#xE262;',
'subE' => '&#x2286;',
'sube' => '&#x2286;',
'subedot' => '&#xE34F;',
'submult' => '&#xE343;',
'subnE' => '&#x228A;',
'subne' => '&#x228A;',
'subplus' => '&#xE341;',
'subrarr' => '&#xE33F;',
'Subset' => '&#x22D0;',
'subset' => '&#x2282;',
'subseteq' => '&#x2286;',
'subseteqq' => '&#x2286;',
'SubsetEqual' => '&#x2286;',
'subsetneq' => '&#x228A;',
'subsetneqq' => '&#x228A;',
'subsim' => '&#xE345;',
'subsub' => '&#xE349;',
'subsup' => '&#xE347;',
'succ' => '&#x227B;',
'succapprox' => '&#x227F;',
'succcurlyeq' => '&#x227D;',
'Succeeds' => '&#x227B;',
'SucceedsEqual' => '&#x227D;',
'SucceedsSlantEqual' => '&#x227D;',
'SucceedsTilde' => '&#x227F;',
'succeq' => '&#x227D;',
'succnapprox' => '&#x22E9;',
'succneqq' => '&#xE2B5;',
'succnsim' => '&#x22E9;',
'succsim' => '&#x227F;',
'SuchThat' => '&#x220D;',
'Sum' => '&#x2211;',
'sum' => '&#x2211;',
'sung' => '&#x2669;',
'Sup' => '&#x22D1;',
'sup' => '&#x2283;',
'sup1' => '&#x00B9;',
'sup2' => '&#x00B2;',
'sup3' => '&#x00B3;',
'supdot' => '&#xE263;',
'supdsub' => '&#xE34C;',
'supE' => '&#x2287;',
'supe' => '&#x2287;',
'supedot' => '&#xE350;',
'Superset' => '&#x2283;',
'SupersetEqual' => '&#x2287;',
'suphsol' => '&#xE34E;',
'suphsub' => '&#xE34B;',
'suplarr' => '&#xE340;',
'supmult' => '&#xE344;',
'supnE' => '&#x228B;',
'supne' => '&#x228B;',
'supplus' => '&#xE342;',
'Supset' => '&#x22D1;',
'supset' => '&#x2283;',
'supseteq' => '&#x2287;',
'supseteqq' => '&#x2287;',
'supsetneq' => '&#x228B;',
'supsetneqq' => '&#x228B;',
'supsim' => '&#xE346;',
'supsub' => '&#xE348;',
'supsup' => '&#xE34A;',
'swarhk' => '&#xE20A;',
'swArr' => '&#x21D9;',
'swarr' => '&#x2199;',
'swarrow' => '&#x2199;',
'swnwar' => '&#xE210;',
'target' => '&#x2316;',
'tau' => '&#x03C4;',
'tbrk' => '&#xE2EF;',
'tdot' => '&#x20DB;',
'telrec' => '&#x2315;',
'Tfr' => '&#xE48F;',
'tfr' => '&#xE4A8;',
'there4' => '&#x2234;',
'Therefore' => '&#x2234;',
'therefore' => '&#x2234;',
'Theta' => '&#x0398;',
'theta' => '&#x03B8;',
'thetav' => '&#x03D1;',
'thickapprox' => '&#xE306;',
'thicksim' => '&#xE429;',
'thinsp' => '&#x2009;',
'thkap' => '&#xE306;',
'thksim' => '&#xE429;',
'Tilde' => '&#x223C;',
'tilde' => '&#x0303;',
'TildeEqual' => '&#x2243;',
'TildeFullEqual' => '&#x2245;',
'TildeTilde' => '&#x2248;',
'times' => '&#x00D7;',
'timesb' => '&#x22A0;',
'timesbar' => '&#xE28E;',
'timesd' => '&#xE26D;',
'tint' => '&#x222D;',
'toea' => '&#xE20E;',
'top' => '&#x22A4;',
'topbot' => '&#x2336;',
'topcir' => '&#xE383;',
'Topf' => '&#xE4BE;',
'topfork' => '&#xE31C;',
'tosa' => '&#xE20F;',
'tprime' => '&#x2034;',
'trade' => '&#x2122;',
'triangle' => '&#x25B5;',
'triangledown' => '&#x25BF;',
'triangleleft' => '&#x25C3;',
'trianglelefteq' => '&#x22B4;',
'triangleq' => '&#x225C;',
'triangleright' => '&#x25B9;',
'trianglerighteq' => '&#x22B5;',
'tridot' => '&#x25EC;',
'trie' => '&#x225C;',
'triminus' => '&#xE27C;',
'TripleDot' => '&#x20DB;',
'triplus' => '&#xE27B;',
'trisb' => '&#xE27E;',
'tritime' => '&#xE27D;',
'trpezium' => '&#xE2EC;',
'Tscr' => '&#xE4D8;',
'tscr' => '&#xE4F1;',
'twixt' => '&#x226C;',
'twoheadleftarrow' => '&#x219E;',
'twoheadrightarrow' => '&#x21A0;',
'Uarr' => '&#x219F;',
'uArr' => '&#x21D1;',
'uarr' => '&#x2191;',
'Uarrocir' => '&#xE237;',
'udarr' => '&#x21C5;',
'udhar' => '&#xE218;',
'ufisht' => '&#xE24B;',
'Ufr' => '&#xE490;',
'ufr' => '&#xE4A9;',
'uHar' => '&#xE226;',
'uharl' => '&#x21BF;',
'uharr' => '&#x21BE;',
'uhblk' => '&#x2580;',
'ulcorn' => '&#x231C;',
'ulcorner' => '&#x231C;',
'ulcrop' => '&#x230F;',
'ultri' => '&#xE2E4;',
'uml' => '&#x0308;',
'UnderLine' => '&#x0332;',
'Union' => '&#x22C3;',
'UnionPlus' => '&#x228E;',
'Uopf' => '&#xE4BF;',
'UpArrow' => '&#x2191;',
'Uparrow' => '&#x21D1;',
'uparrow' => '&#x2191;',
'UpArrowDownArrow' => '&#x21C5;',
'UpDownArrow' => '&#x2195;',
'Updownarrow' => '&#x21D5;',
'updownarrow' => '&#x2195;',
'UpEquilibrium' => '&#xE218;',
'upharpoonleft' => '&#x21BF;',
'upharpoonright' => '&#x21BE;',
'uplus' => '&#x228E;',
'UpperLeftArrow' => '&#x2196;',
'UpperRightArrow' => '&#x2197;',
'Upsi' => '&#x03D2;',
'upsi' => '&#x03C5;',
'Upsilon' => '&#x03D2;',
'upsilon' => '&#x03C5;',
'UpTee' => '&#x22A5;',
'upuparrows' => '&#x21C8;',
'urcorn' => '&#x231D;',
'urcorner' => '&#x231D;',
'urcrop' => '&#x230E;',
'urtri' => '&#xE2E2;',
'Uscr' => '&#xE4D9;',
'uscr' => '&#xE4F2;',
'utdot' => '&#x22F0;',
'utri' => '&#x25B5;',
'utrif' => '&#x25B4;',
'uuarr' => '&#x21C8;',
'uwangle' => '&#xE3AB;',
'vangrt' => '&#x22BE;',
'varepsilon' => '&#x03B5;',
'varkappa' => '&#x03F0;',
'varnothing' => '&#x2205;',
'varphi' => '&#x03D5;',
'varpi' => '&#x03D6;',
'varpropto' => '&#x221D;',
'vArr' => '&#x21D5;',
'varr' => '&#x2195;',
'varrho' => '&#x03F1;',
'varsigma' => '&#x03C2;',
'varsubsetneq' => '&#xE2B9;',
'varsubsetneqq' => '&#xE2B8;',
'varsupsetneq' => '&#xE2BA;',
'varsupsetneqq' => '&#xE2BB;',
'vartheta' => '&#x03D1;',
'vartriangleleft' => '&#x22B2;',
'vartriangleright' => '&#x22B3;',
'Vbar' => '&#xE30D;',
'vBar' => '&#xE310;',
'vBarv' => '&#xE312;',
'VDash' => '&#x22AB;',
'Vdash' => '&#x22A9;',
'vDash' => '&#x22A8;',
'vdash' => '&#x22A2;',
'Vdashl' => '&#xE313;',
'Vee' => '&#x22C1;',
'vee' => '&#x2228;',
'veebar' => '&#x22BB;',
'veeeq' => '&#x225A;',
'vellip' => '&#x22EE;',
'Verbar' => '&#x2016;',
'verbar' => '&#x007C;',
'Vert' => '&#x2016;',
'vert' => '&#x007C;',
'VerticalBar' => '&#x2223;',
'VerticalTilde' => '&#x2240;',
'Vfr' => '&#xE491;',
'vfr' => '&#xE4AA;',
'vltri' => '&#x22B2;',
'vnsub' => '&#x2284;',
'vnsup' => '&#x2285;',
'Vopf' => '&#xE4C0;',
'vprop' => '&#x221D;',
'vrtri' => '&#x22B3;',
'Vscr' => '&#xE4DA;',
'vscr' => '&#xE4F3;',
'vsubnE' => '&#xE2B8;',
'vsubne' => '&#xE2B9;',
'vsupnE' => '&#xE2BB;',
'vsupne' => '&#xE2BA;',
'Vvdash' => '&#x22AA;',
'vzigzag' => '&#xE2EB;',
'wedbar' => '&#xE265;',
'Wedge' => '&#x22C0;',
'wedge' => '&#x2227;',
'wedgeq' => '&#x2259;',
'weierp' => '&#x2118;',
'Wfr' => '&#xE492;',
'wfr' => '&#xE4AB;',
'Wopf' => '&#xE4C1;',
'wp' => '&#x2118;',
'wr' => '&#x2240;',
'wreath' => '&#x2240;',
'Wscr' => '&#xE4DB;',
'wscr' => '&#xE4F4;',
'xcap' => '&#x22C2;',
'xcirc' => '&#x25CB;',
'xcup' => '&#x22C3;',
'xdtri' => '&#x25BD;',
'Xfr' => '&#xE493;',
'xfr' => '&#xE4AC;',
'xhArr' => '&#xE202;',
'xharr' => '&#xE203;',
'Xi' => '&#x039E;',
'xi' => '&#x03BE;',
'xlArr' => '&#xE200;',
'xlarr' => '&#xE201;',
'xmap' => '&#xE208;',
'xnis' => '&#xE3A3;',
'xodot' => '&#x2299;',
'Xopf' => '&#xE4C2;',
'xoplus' => '&#x2295;',
'xotime' => '&#x2297;',
'xrArr' => '&#xE204;',
'xrarr' => '&#xE205;',
'Xscr' => '&#xE4DC;',
'xscr' => '&#xE4F5;',
'xsqcup' => '&#x2294;',
'xuplus' => '&#x228E;',
'xutri' => '&#x25B3;',
'xvee' => '&#x22C1;',
'xwedge' => '&#x22C0;',
'yen' => '&#x00A5;',
'Yfr' => '&#xE494;',
'yfr' => '&#xE4AD;',
'Yopf' => '&#xE4C3;',
'Yscr' => '&#xE4DD;',
'yscr' => '&#xE4F6;',
'zeta' => '&#x03B6;',
'Zfr' => '&#x2124;',
'zfr' => '&#xE4AE;',
'zigrarr' => '&#xE244;',
'Zopf' => '&#xE4C4;',
'Zscr' => '&#xE4DE;',
'zscr' => '&#xE4F7;'
);
?>
<?php
// translitteration simple
$GLOBALS['CHARSET']['translit'] = array (
// latin [fausse plage]
128=>'EUR', 131=>'f', 140=>'OE', 147=>'\'\'', 148=>'\'\'',
153=>'(TM)', 156=>'oe', 159=>'Y',
// latin [legal]
160=>' ', 161=>'!', 162=>'c', 163=>'L', 164=>'O', 165=>'yen',166=>'|',
167=>'p',169=>'(c)', 171=>'<<',172=>'-',173=>'-',174=>'(R)',
176=>'o',177=>'+-',181=>'mu',182=>'p',183=>'.',186=>'o ',187=>'>>',
191=>'?', 192=>'A',
193=>'A', 194=>'A', 195=>'A', 196=>'A', 197=>'A', 198=>'AE', 199=>'C',
200=>'E', 201=>'E', 202=>'E', 203=>'E', 204=>'I', 205=>'I', 206=>'I',
207=>'I', 209=>'N', 210=>'O', 211=>'O', 212=>'O', 213=>'O', 214=>'O',
216=>'O', 217=>'U', 218=>'U', 219=>'U', 220=>'U', 223=>'ss', 224=>'a',
225=>'a', 226=>'a', 227=>'a', 228=>'a', 229=>'a', 230=>'ae', 231=>'c',
232=>'e', 233=>'e', 234=>'e', 235=>'e', 236=>'i', 237=>'i', 238=>'i',
239=>'i', 241=>'n', 242=>'o', 243=>'o', 244=>'o', 245=>'o', 246=>'o',
248=>'o', 249=>'u', 250=>'u', 251=>'u', 252=>'u', 255=>'y',
// turc
286=>'G', 287=>'g', 304=>'I', 305=>'i', 350=>'S', 351=>'s',
// esperanto
264 => 'Cx',265 => 'cx',
284 => 'Gx',285 => 'gx',
292 => 'Hx',293 => 'hx',
308 => 'Jx',309 => 'jx',
348 => 'Sx',349 => 'sx',
364 => 'Ux',365 => 'ux',
// latin2 [Czech]
283=>'e', 353=>'s', 269=>'c', 345=>'r', 382=>'z',
367=>'u', 328=>'n', 357=>'t', 271=>'d', 449=>'o',
282=>'E', 352=>'S', 268=>'C', 344=>'R', 381=>'Z',
366=>'U', 327=>'N', 356=>'T', 270=>'D', 467=>'O',
// francais
338=>'OE', 339=>'oe', 376=>'Y', 402=>'f',
//polskie
260=>'A', 261=>'a', 262=>'C', 263=>'c',
280=>'E', 281=>'e', 321=>'L', 322=>'l',
323=>'N', 324=>'n', 346=>'S', 347=>'s',
377=>'Z', 378=>'z', 379=>'Z', 380=>'z',
//roumain
258=>'A', 259=>'a', 350=>'S', 351=>'s', 354=>'T', 355=>'t',
// cyrillique
1026=>'D%', 1027=>'G%', 8218=>'\'', 1107=>'g%', 8222=>'"', 8230=>'...',
8224=>'/-', 8225=>'/=', 8364=>'EUR', 8240=>'0/00', 1033=>'LJ',
8249=>'<', 1034=>'NJ', 1036=>'KJ', 1035=>'Ts', 1039=>'DZ', 1106=>'d%',
8216=>'`', 8217=>'\'', 8220=>'"', 8221=>'"', 8226=>' o ', 8211=>'-',
8212=>'--', 8212=>'~', 8482=>'(TM)', 1113=>'lj', 8250=>'>', 1114=>'nj',
1116=>'kj', 1115=>'ts', 1119=>'dz', 1038=>'V%', 1118=>'v%', 1032=>'J%',
1168=>'G3', 1025=>'IO', 1028=>'IE', 1031=>'YI', 1030=>'II',
1110=>'ii', 1169=>'g3', 1105=>'io', 8470=>'No.', 1108=>'ie',
1112=>'j%', 1029=>'DS', 1109=>'ds', 1111=>'yi', 1040=>'A', 1041=>'B',
1042=>'V', 1043=>'G', 1044=>'D', 1045=>'E', 1046=>'ZH', 1047=>'Z',
1048=>'I', 1049=>'J', 1050=>'K', 1051=>'L', 1052=>'M', 1053=>'N',
1054=>'O', 1055=>'P', 1056=>'R', 1057=>'S', 1058=>'T', 1059=>'U',
1060=>'F', 1061=>'H', 1062=>'C', 1063=>'CH', 1064=>'SH', 1065=>'SCH',
1066=>'"', 1067=>'Y', 1068=>'\'', 1069=>'`E', 1070=>'YU', 1071=>'YA',
1072=>'a', 1073=>'b', 1074=>'v', 1075=>'g', 1076=>'d', 1077=>'e',
1078=>'zh', 1079=>'z', 1080=>'i', 1081=>'j', 1082=>'k', 1083=>'l',
1084=>'m', 1085=>'n', 1086=>'o', 1087=>'p', 1088=>'r', 1089=>'s',
1090=>'t', 1091=>'u', 1092=>'f', 1093=>'h', 1094=>'c', 1095=>'ch',
1096=>'sh', 1097=>'sch', 1098=>'"', 1099=>'y', 1100=>'\'', 1101=>'`e',
1102=>'yu', 1103=>'ya',
// vietnamien en translitteration de base
7843=>"a",7841=>"a",7845=>"a",7847=>"a",7849=>"a",7851=>"a",7853=>"a",
7855=>"a",7857=>"a",7859=>"a",7861=>"a",7863=>"a",
7842=>"A",7840=>"A",7844=>"A",7846=>"A",7848=>"A",
7850=>"A",7852=>"A",7854=>"A",7856=>"A",7858=>"A",7860=>"A",
7862=>"A",7867=>"e",7869=>"e",7865=>"e",
7871=>"e",7873=>"e",7875=>"e",7877=>"e",7879=>"e",
7866=>"E",7868=>"E",7864=>"E",7870=>"E",7872=>"E",7874=>"E",
7876=>"E",7878=>"E",7881=>"i",7883=>"i",
7880=>"I",7882=>"I",
7887=>"o",7885=>"o",7889=>"o",7891=>"o",7893=>"o",
7895=>"o",7897=>"o",417=>"o",7899=>"o",7901=>"o",7903=>"o",7905=>"o",
7907=>"o",7886=>"O",7884=>"O",
7888=>"O",7890=>"O",7892=>"O",7894=>"O",7896=>"O",416=>"O",7898=>"O",
7900=>"O",7902=>"O",7904=>"O",7906=>"O",7911=>"u",
361=>"u",7909=>"u",432=>"u",7913=>"u",7915=>"u",7917=>"u",7919=>"u",
7921=>"u",7910=>"U",360=>"U",7908=>"U",431=>"U",
7912=>"U",7914=>"U",7916=>"U",7918=>"U",7920=>"U",253=>"y",7923=>"y",
7927=>"y",7929=>"y",7925=>"y",221=>"Y",7922=>"Y",7926=>"Y",7928=>"Y",
7924=>"Y",273=>"d"
);
?>