url
delta_sub (url base, url u) {
if (is_atomic (base))
return u;
if (is_concat (base) && is_concat (u) && (base[1] == u[1])) {
if (is_special_root (base[1]) &&
is_concat (base[2]) && is_concat (u[2]) &&
base[2][1] != u[2][1])
return url_none ();
return delta_sub (base[2], u[2]);
}
if (is_concat (base) && !is_semi_root (base))
return url_parent () * delta_sub (head (base), u);
return url_none ();
}
url
resolve_tex (url name) {
string s= as_string (name);
if (is_cached ("font_cache.scm", s)) {
url u= url_system (cache_get ("font_cache.scm", s) -> label);
if (exists (u)) return u;
cache_reset ("font_cache.scm", s);
}
bench_start ("resolve tex");
url u= url_none ();
if (ends (s, "mf" )) {
u= resolve_tfm (name);
#ifdef OS_WIN32
if (is_none (u))
u= resolve_tfm (replace (s, ".mf", ".tfm"));
#endif
}
if (ends (s, "tfm")) u= resolve_tfm (name);
if (ends (s, "pk" )) u= resolve_pk (name);
if (ends (s, "pfb")) u= resolve_pfb (name);
bench_cumul ("resolve tex");
if (!is_none (u)) cache_set ("font_cache.scm", s, as_string (u));
//cout << "Resolve " << name << " -> " << u << "\n";
return u;
}
static void
init_main_paths () {
#ifdef __MINGW32__
if (is_none (get_env_path ("TEXMACS_HOME_PATH", get_env ("APPDATA") * "/TeXmacs"))) {
#else
if (is_none (get_env_path ("TEXMACS_HOME_PATH", "~/.TeXmacs"))) {
#endif
boot_error << "\n";
boot_error << "Installation problem: please send a bug report.\n";
boot_error << "'TEXMACS_HOME_PATH' could not be set to '~/.TeXmacs'.\n";
boot_error << "You may try to set this environment variable manually\n";
boot_error << "\n";
FAILED ("installation problem");
exit (1);
}
}
/******************************************************************************
* Directory for temporary files
******************************************************************************/
static string main_tmp_dir= "$TEXMACS_HOME_PATH/system/tmp";
static void
make_dir (url which) {
if (!is_directory (which)) {
make_dir (head (which));
mkdir (which);
}
}
static url
url_temp_dir_sub () {
#ifdef __MINGW32__
static url tmp_dir=
url_system (main_tmp_dir) * url_system (as_string (time (NULL)));
#else
static url tmp_dir=
url_system (main_tmp_dir) * url_system (as_string ((int) getpid ()));
#endif
return (tmp_dir);
}
url
url_temp_dir () {
static url u;
if (u == url_none()) {
u= url_temp_dir_sub ();
make_dir (u);
}
return u;
}
bool
process_running (int pid) {
string cmd= "ps -p " * as_string (pid);
string ret= eval_system (cmd);
return occurs ("texmacs", ret) && occurs (as_string (pid), ret);
}
url
get_from_web (url name) {
if (!is_rooted_web (name)) return url_none ();
url res= get_cache (name);
if (!is_none (res)) return res;
#ifdef OS_WIN32
string urlString = as_string (name);
url tmp = url_temp();
if (starts (urlString, "www."))
urlString = "http://" * urlString;
else if (starts (urlString, "ftp."))
urlString = "ftp://" * urlString;
else if (starts (urlString, "ftp://"))
urlPath = NULL;
else if (starts (urlString, "http://"))
urlPath = NULL;
else
urlString = "http://" * urlString;
urlString= web_encode (urlString);
c_string urlPath (urlString);
c_string tempFilePath (as_string (tmp));
if(!URL_Get(urlPath, tempFilePath))
return url_none();
else return set_cache (name, tmp);
#else
string test= var_eval_system ("which wget");
if (!ends (test, "wget")) return url_none ();
url tmp= url_temp ();
string tmp_s= escape_sh (concretize (tmp));
string cmd= "wget --header='User-Agent: TeXmacs-" TEXMACS_VERSION "' -q";
cmd << " -O " << tmp_s << " " << escape_sh (web_encode (as_string (name)));
// cout << cmd << "\n";
system (cmd);
// cout << "got " << name << " as " << tmp << "\n";
if (var_eval_system ("cat " * tmp_s * " 2> /dev/null") == "") {
remove (tmp);
return url_none ();
}
else return set_cache (name, tmp);
#endif
}
url
get_from_ramdisc (url u) {
if (!is_ramdisc (u)) return url_none ();
url res= get_cache (u);
if (!is_none (res)) return (res);
url tmp= url_temp (string (".") * suffix (u));
save_string (tmp, u[1][2]->t->label);
return set_cache (u, tmp);
}
tm_window_rep::tm_window_rep (tree doc, command quit):
win (texmacs_widget (0, quit)),
wid (win), id (url_none ()),
serial (tm_window_serial++),
menu_current (object ()), menu_cache (widget ()),
text_ptr (NULL)
{
(void) doc;
zoomf= get_server () -> get_default_zoom_factor ();
}
void
reset_pfb_path () {
string pfb= get_setting ("PFB");
the_pfb_path=
url_here () |
search_sub_dirs ("$TEXMACS_HOME_PATH/fonts/type1") |
search_sub_dirs ("$TEXMACS_PATH/fonts/type1") |
"$TEX_PFB_PATH" |
(pfb == ""? url_none (): url_system (pfb));
the_pfb_path= expand (factor (the_pfb_path));
}
static url
url_get_path (string s, int type= URL_STANDARD, int i=0) {
char sep= (type == URL_SYSTEM)? URL_SEPARATOR: ':';
int start= i, n= N(s);
if (i == n) return url_none ();
while ((i<n) && (s[i] != sep)) i++;
url u= url_general (s (start, i), type);
if (i == n) return u;
if (start == i) return url_get_path (s, type, i+1);
return u | url_get_path (s, type, i+1);
}
static url
get_kpsepath (string s) {
// FIXME: adapt to WIN32
if (get_setting ("KPSEPATH") != "true") return url_none ();
string r= var_eval_system ("kpsepath " * s);
if (N(r)==0) return url_none ();
int i, start, end;
url p= url_none ();
for (i=0; i<N(r); i++) {
while ((i<N(r)) && (r[i]=='!')) i++;
start=i;
while ((i<N(r)) && (r[i]!=':')) i++;
end=i;
while ((end>start) && (r[end-1]=='/')) end--;
string dir= r (start, end);
if (dir == ".") continue;
p= expand (complete (dir * url_wildcard (), "dr")) | p;
}
return p;
}
url
find_bib_file (url base, string fname,
string suffix= ".bib", bool rooted= false) {
if (!ends (fname, suffix)) fname= fname * suffix;
url bibf (fname);
if (exists (bibf) && (!rooted || is_rooted (bibf)))
return bibf;
if (exists (relative (base, bibf)))
return relative (base, bibf);
if (exists (expand (relative (base, url_ancestor () * bibf))))
return resolve (expand (relative (base, url_ancestor () * bibf)));
return url_none ();
}
url
get_from_server (url u) {
if (!is_rooted_tmfs (u)) return url_none ();
url res= get_cache (u);
if (!is_none (res)) return res;
string name= as_string (u);
if (ends (name, "~") || ends (name, "#")) {
if (!is_rooted_tmfs (name)) return url_none ();
if (!as_bool (call ("tmfs-can-autosave?", unglue (u, 1))))
return url_none ();
}
string r= as_string (call ("tmfs-load", object (name)));
if (r == "") return url_none ();
url tmp= url_temp ();
(void) save_string (tmp, r, true);
//return set_cache (u, tmp);
return tmp;
// FIXME: certain files could be cached, but others not
// for instance, files which are loaded in a delayed fashion
// would always be cached as empty files, which is erroneous.
}
url
operator * (url u1, url u2) {
//cout << "concat " << u1->t << " * " << u2->t << "\n";
if (is_root (u2) || (is_concat (u2) && is_root (u2[1]))) {
if (is_concat (u1) && is_root_web (u1[1])) {
if (is_root (u2, "default") ||
(is_concat (u2) && is_root (u2[1], "default")))
{
url v= u1[2];
while (is_concat (v)) v= v[1];
if (is_root (u2)) return u1[1] * v;
return u1[1] * v * u2[2];
}
if (is_root (u2, "blank") ||
(is_concat (u2) && is_root (u2[1], "blank")))
return reroot (u2, u1[1][1]->t->label);
}
return u2;
}
if (is_here (u1) || (u1->t == "")) return u2;
if (is_here (u2)) return u1;
if (is_none (u1)) return url_none ();
if (is_none (u2)) return url_none ();
if (u2 == url_parent ()) {
if (is_root (u1)) return u1;
if (is_pseudo_atomic (u1) && (!is_parent (u1))) return url_here ();
if (is_semi_root (u1)) return u1;
}
if (is_concat (u2) && (u2[1] == url_parent ())) {
if (is_root (u1)) return u1 * u2[2];
if (is_pseudo_atomic (u1) && (!is_parent (u1))) return u2[2];
if (is_semi_root (u1)) return u1 * u2[2];
}
if (is_concat (u1)) return u1[1] * (u1[2] * u2);
return as_url (tuple ("concat", u1->t, u2->t));
}
static url
url_get_atom (string s, int type) {
if (type < URL_STANDARD) {
if (s == "~") return url_system (get_env ("HOME"));
if (starts (s, "$")) {
string val= get_env (s (1, N(s)));
if (val == "") return url_none ();
return unblank (url_system (val));
}
}
if (occurs ("*", s)) return url_wildcard (s);
#ifdef WINPATHS
if(N(s)==2 && ends (s, ":")) s->resize(1); // remove the ':' after unit letter
#endif
return as_url (tree (s));
}
void
reset_pk_path (bool rehash) { (void) rehash;
// if (rehash && (get_setting ("TEXHASH") == "true")) system ("texhash");
string pk= get_setting ("PK");
the_pk_path=
url_here () |
search_sub_dirs ("$TEXMACS_HOME_PATH/fonts/pk") |
search_sub_dirs ("$TEXMACS_PATH/fonts/pk") |
"$TEX_PK_PATH" |
(pk == ""? url_none (): pk);
if ((get_setting ("MAKEPK") != "false") ||
(get_setting ("TEXHASH") == "true"))
if (get_setting ("KPSEWHICH") != "true")
the_pk_path= the_pk_path | get_kpsepath ("pk");
the_pk_path= expand (factor (the_pk_path));
}
void
reset_tfm_path (bool rehash) { (void) rehash;
// if (rehash && (get_setting ("TEXHASH") == "true")) system ("texhash");
string tfm= get_setting ("TFM");
the_tfm_path=
url_here () |
search_sub_dirs ("$TEXMACS_HOME_PATH/fonts/tfm") |
search_sub_dirs ("$TEXMACS_PATH/fonts/tfm") |
"$TEX_TFM_PATH" |
(tfm == ""? url_none (): tfm);
if ((get_setting ("MAKETFM") != "false") ||
(get_setting ("TEXHASH") == "true"))
if (get_setting ("KPSEWHICH") != "true")
the_tfm_path= the_tfm_path | get_kpsepath ("tfm");
the_tfm_path= expand (factor (the_tfm_path));
}
static url
get_cache (url name) {
if (web_cache_resolve->contains (name->t)) {
int i, j;
tree tmp= web_cache_resolve [name->t];
for (i=0; i<MAX_CACHED; i++)
if (web_cache[i] == name->t) {
// cout << name << " in cache as " << tmp << " at " << i << "\n";
for (j=i; ((j+1) % MAX_CACHED) != web_nr; j= (j+1) % MAX_CACHED)
web_cache[j]= web_cache[(j+1) % MAX_CACHED];
web_cache[j]= name->t;
break;
}
return as_url (tmp); // url_system (tmp);
}
return url_none ();
}
void
concater_rep::typeset_sound (tree t, path ip) {
if (N(t) != 1) { typeset_error (t, ip); return; }
player pl= get_player (env->get_animation_ip (ip));
tree sound_t= env->exec (t[0]);
url sound= url_none ();
if (is_atomic (sound_t)) {
url sound_u= sound_t->label;
sound= resolve (relative (env->base_file_name, sound_u));
}
if (!is_none (sound)) {
int sz= script (env->fn_size, env->index_level);
font gfn (tex_font ("cmr", sz, (int) (env->magn*env->dpi)));
print (sound_box (ip, pl, sound, gfn->yx));
flag ("sound", ip, brown);
}
else typeset_dynamic (tree (ERROR, "bad sound", t[0]), ip);
}
void
edit_main_rep::print_buffer (string first, string last) {
// in Qt this is the main entry point to the printing subsystem.
// the other routines (print_to_file, ...) are overriden since all fine tuning
// is made here via the Qt print dialog
bool to_file, landscape;
url name = url_none();
string printer;
string paper_type;
if (qt_print (to_file, landscape, printer, name, first, last, paper_type)) {
if (!to_file) name = url_temp (".ps");
print (name, false, as_int (first), as_int (last));
if (!to_file) {
string cmd = printing_cmd * " -P" * printer;
system (cmd, name);
::remove (name);
}
}
}
void
concater_rep::typeset_video (tree t, path ip) {
if (N(t) != 5) { typeset_error (t, ip); return; }
player pl= get_player (env->get_animation_ip (ip));
tree video_t= env->exec (t[0]);
url video= url_none ();
if (is_atomic (video_t)) {
url video_u= video_t->label;
video= resolve (relative (env->base_file_name, video_u));
}
if (!is_none (video)) {
SI w = env->as_length (env->exec (t[1]));
SI h = env->as_length (env->exec (t[2]));
int len= env->as_length (env->exec (t[3]));
bool rep= env->exec (t[4]) != "false";
print (video_box (ip, pl, video, w, h, env->alpha, len, rep, env->pixel));
}
else typeset_dynamic (tree (ERROR, "bad video", t[0]), ip);
}
url
tmfs_get_root (string prj) {
collection c= tmfs_query (seq ("root", prj, "?url"), "?url");
if (N(c) != 1) return url_none ();
return url (first (c));
}
url
picture_rep::get_name () {
return url_none ();
}
url
complete (url base, url u, string filter, bool flag) {
// cout << "complete " << base << " |||| " << u << LF;
if (!is_rooted(u)) {
if (is_none (base)) return base;
if (is_none (u)) return u;
if ((!is_root (base)) && (!is_rooted_name (base))) {
failed_error << "base= " << base << LF;
FAILED ("invalid base url");
}
}
if (is_name (u) || (is_concat (u) && is_root (u[1]) && is_name (u[2]))) {
url comp= base * u;
if (is_rooted (comp, "default") || is_rooted (comp, "file")) {
if (is_of_type (comp, filter)) return reroot (u, "default");
return url_none ();
}
if (is_rooted_web (comp) || is_rooted_tmfs (comp) || is_ramdisc (comp)) {
if (is_of_type (comp, filter)) return u;
return url_none ();
}
failed_error << "base= " << base << LF;
failed_error << "u= " << u << LF;
ASSERT (is_rooted (comp), "unrooted url");
FAILED ("bad protocol in url");
}
if (is_root (u)) {
// FIXME: test filter flags here
return u;
}
if (is_concat (u) && is_wildcard (u[1], 0) && is_wildcard (u[2], 1)) {
// FIXME: ret= ret | ... is unefficient (quadratic) in main loop
if (!(is_rooted (base, "default") || is_rooted (base, "file"))) {
failed_error << "base= " << base << LF;
FAILED ("wildcards only implemented for files");
}
url ret= url_none ();
bool error_flag;
array<string> dir= read_directory (base, error_flag);
int i, n= N(dir);
for (i=0; i<n; i++) {
if ((!is_none (ret)) && flag) return ret;
if ((dir[i] == ".") || (dir[i] == "..")) continue;
if (starts (dir[i], "http://") || starts (dir[i], "ftp://"))
if (is_directory (base * dir[i])) continue;
ret= ret | (dir[i] * complete (base * dir[i], u, filter, flag));
if (match_wildcard (dir[i], u[2][1]->t->label))
ret= ret | complete (base, dir[i], filter, flag);
}
return ret;
}
if (is_concat (u)) {
url sub= complete (base, u[1], "", false);
// "" should often be faster than the more correct "d" here
return complete (base, sub, u[2], filter, flag);
}
if (is_or (u)) {
url res1= complete (base, u[1], filter, flag);
if ((!is_none (res1)) && flag) return res1;
return res1 | complete (base, u[2], filter, flag);
}
if (is_wildcard (u)) {
// FIXME: ret= ret | ... is unefficient (quadratic) in main loop
if (!(is_rooted (base, "default") || is_rooted (base, "file"))) {
failed_error << "base= " << base << LF;
FAILED ("wildcards only implemented for files");
}
url ret= url_none ();
if (is_wildcard (u, 0) && is_of_type (base, filter)) ret= url_here ();
bool error_flag;
array<string> dir= read_directory (base, error_flag);
int i, n= N(dir);
for (i=0; i<n; i++) {
if ((!is_none (ret)) && flag) return ret;
if ((dir[i] == ".") || (dir[i] == "..")) continue;
if (starts (dir[i], "http://") || starts (dir[i], "ftp://"))
if (is_directory (base * dir[i])) continue;
if (is_wildcard (u, 0))
ret= ret | (dir[i] * complete (base * dir[i], u, filter, flag));
else if (match_wildcard (dir[i], u[1]->t->label))
ret= ret | complete (base, dir[i], filter, flag);
}
return ret;
}
failed_error << "url= " << u << LF;
FAILED ("bad url");
return u;
}
#include "config.h" #include "tm_server.hpp" #include "drd_std.hpp" #include "convert.hpp" #include "connect.hpp" #include "sys_utils.hpp" #include "file.hpp" #include "analyze.hpp" #include "dictionary.hpp" #include "tm_link.hpp" #include "socket_notifier.hpp" #include "new_style.hpp" server* the_server= NULL; bool texmacs_started= false; url tm_init_file= url_none (); url my_init_file= url_none (); string my_init_cmds= ""; /****************************************************************************** * Execution of commands ******************************************************************************/ void reset_inclusions (); extern string printing_dpi; extern string printing_cmd; extern string printing_on; extern int nr_windows; /****************************************************************************** * Texmacs server constructor and destructor
* This software falls under the GNU general public license version 3 or later.
* It comes WITHOUT ANY WARRANTY WHATSOEVER. For details, see the file LICENSE
* in the root directory or <http://www.gnu.org/licenses/gpl-3.0.html>.
******************************************************************************/
#include "tex_files.hpp"
#include "boot.hpp"
#include "file.hpp"
#include "sys_utils.hpp"
#include "path.hpp"
#include "hashmap.hpp"
#include "analyze.hpp"
#include "timer.hpp"
#include "data_cache.hpp"
static url the_tfm_path= url_none ();
static url the_pk_path = url_none ();
static url the_pfb_path= url_none ();
/******************************************************************************
* Finding a TeX font
******************************************************************************/
static string
kpsewhich (string name) {
bench_start ("kpsewhich");
string which= var_eval_system ("kpsewhich " * name);
bench_cumul ("kpsewhich");
return which;
}
