diff options
author | Karl Berry <karl@freefriends.org> | 2006-01-17 21:41:51 +0000 |
---|---|---|
committer | Karl Berry <karl@freefriends.org> | 2006-01-17 21:41:51 +0000 |
commit | 487ca4806cc046076293cf6cc5fbba0db282bac7 (patch) | |
tree | 847b412ab5158dd7bdd7ed7e5a4cc3fbca94be32 /Build/source/texk/tex4htk/t4ht.c | |
parent | a3d3111bfe26b8e5f5bc6049dfb2a4ca2edc7881 (diff) |
texk 1
git-svn-id: svn://tug.org/texlive/trunk@1485 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/texk/tex4htk/t4ht.c')
-rw-r--r-- | Build/source/texk/tex4htk/t4ht.c | 2946 |
1 files changed, 2946 insertions, 0 deletions
diff --git a/Build/source/texk/tex4htk/t4ht.c b/Build/source/texk/tex4htk/t4ht.c new file mode 100644 index 00000000000..a7245202f85 --- /dev/null +++ b/Build/source/texk/tex4htk/t4ht.c @@ -0,0 +1,2946 @@ + +/**********************************************************/ +/* t4ht.c 2005-08-04-07:03 */ +/* Copyright (C) 1998--2005 Eitan M. Gurari */ +/* */ +/* This work may be distributed and/or modified under the */ +/* conditions of the LaTeX Project Public License, either */ +/* version 1.3 of this license or (at your option) any */ +/* later version. The latest version of this license is */ +/* in */ +/* http://www.latex-project.org/lppl.txt */ +/* and version 1.3 or later is part of all distributions */ +/* of LaTeX version 2003/12/01 or later. */ +/* */ +/* This work has the LPPL maintenance status "maintained".*/ +/* */ +/* This Current Maintainer of this work */ +/* is Eitan M. Gurari. */ +/* */ +/* If you modify this program your changing its signature */ +/* with a directive of the following form will be */ +/* appreciated. */ +/* #define PLATFORM "signature" */ +/* */ +/* gurari@cse.ohio-state.edu */ +/* http://www.cse.ohio-state.edu/~gurari */ +/**********************************************************/ + +/* ********************************************** + Compiler options * + (uncommented | command line) * +------------------------------------------------* + Classic C (CC) default +#define ANSI ansi-c, c++ +#define DOS_C +#define HAVE_STRING_H <string.h> +#define HAVE_DIRENT_H <dirent.h> +#define HAVE_SYS_NDIR_H <sys/ndir.h> +#define HAVE_SYS_DIR_H <sys/dir.h> +#define HAVE_NDIR_H <ndir.h> +#define HAVE_IO_H <io.h> +#define HAVE_UNISTD_H <unistd.h> +#define WIN32 +#define KPATHSEA +#define SYSTEM_FUNCTION_OK +#define CDECL .......... +#define BCC32 bordland c++ + +************************************************* + Tex4ht variables * + (uncommented | command line) * +----------------------------------------------- */ + +#ifndef ENVFILE + +#endif + + +/* ******************************************** */ + + +#ifdef BCC32 +#define WIN32 +#define ANSI +#define HAVE_IO_H +#define HAVE_STRING_H +#define PLATFORM "ms-win32" +#endif + + + +#ifdef BCC +#define DOS_C +#define ANSI +#define HAVE_IO_H +#define PLATFORM "ms-dos" +#endif + + + +#ifdef __DJGPP__ +#define DOS_WIN32 +#define ANSI +#endif + + +#ifdef DOS_C +#define DOS +#endif +#ifdef DOS +#define DOS_WIN32 +#ifndef HAVE_STRING_H +#define HAVE_STRING_H +#endif +#endif +#ifdef WIN32 +#define DOS_WIN32 +#endif + +#ifdef DOS_WIN32 +#define STRUCT_DIRENT +#endif + + + +#ifdef KPATHSEA +#ifdef WIN32 +#define KWIN32 +#endif +#endif + + + +#include <stdio.h> +#include <stdlib.h> + + +#ifdef HAVE_STRING_H +#include <string.h> +#endif + + +#ifdef HAVE_DIRENT_H + +#include <dirent.h> + + +#else +#ifndef STRUCT_DIRENT +#define STRUCT_DIRECT +#endif + +#ifdef HAVE_SYS_NDIR_H +#include <sys/ndir.h> +#endif +#ifdef HAVE_SYS_DIR_H +#include <sys/dir.h> +#endif +#ifdef HAVE_NDIR_H +#include <ndir.h> +#endif + + +#endif + + +#include <signal.h> + + + + +#ifndef __DJGPP__ + +#ifndef F_OK +#ifdef DOS_WIN32 +#define F_OK 0 +#endif +#ifndef KPATHSEA +#ifndef DOS_WIN32 +#define HAVE_UNISTD_H +#endif +#endif +#endif +#ifdef HAVE_IO_H +#include <io.h> +#endif +#ifndef KPATHSEA +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#endif + + +#endif + + +#ifdef KPATHSEA +#include <kpathsea/config.h> +#include <kpathsea/c-errno.h> +#include <kpathsea/c-ctype.h> +#include <kpathsea/c-fopen.h> +#include <kpathsea/c-pathmx.h> +#include <kpathsea/proginit.h> +#include <kpathsea/tex-file.h> +#include <kpathsea/tex-make.h> +#include <kpathsea/variable.h> +#include <signal.h> +#if !defined(_AMIGA) && !defined(WIN32) +#include <sys/time.h> +#endif +#include <fcntl.h> +#include <setjmp.h> +#endif + +#ifdef __DJGPP__ + +#ifndef F_OK +#ifdef DOS_WIN32 +#define F_OK 0 +#endif +#ifndef KPATHSEA +#ifndef DOS_WIN32 +#define HAVE_UNISTD_H +#endif +#endif +#endif +#ifdef HAVE_IO_H +#include <io.h> +#endif +#ifndef KPATHSEA +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#endif + + +#endif + + + + + + +#ifdef DOS +#define PROTOTYP +#endif +#ifdef ANSI +#define PROTOTYP +#endif +#ifdef KWIN32 +#define PROTOTYP +#endif + + +#ifdef KPATHSEA +#ifdef WIN32 +#undef CDECL +#define CDECL __cdecl +#else +#define CDECL +#endif +#endif + + +#if defined(DOS_WIN32) || defined(__MSDOS__) +#define READ_BIN_FLAGS "rb" +#define READ_TEXT_FLAGS "r" +#define WRITE_BIN_FLAGS "wb" +#define WRITE_TEXT_FLAGS "w" +#else +#define READ_BIN_FLAGS "r" +#define READ_TEXT_FLAGS "r" +#define WRITE_BIN_FLAGS "w" +#define WRITE_TEXT_FLAGS "w" +#endif + + + +#define Q_CHAR char +#define U_CHAR char +#define C_CHAR char +#define Q_NULL (Q_CHAR *) 0 +#define U_NULL (U_CHAR *) 0 +#define C_NULL (C_CHAR *) 0 + + +#define IGNORED void + + +#ifndef EXIT_FAILURE +#define EXIT_FAILURE 1 +#endif + + +#ifdef PROTOTYP +#define MYVOID void +#define ARG_I(x) x +#define ARG_II(x,y) x,y +#define ARG_III(x,y,z) x,y,z +#define ARG_IV(x,y,z,w) x,y,z,w +#define ARG_V(x,y,z,w,u) x,y,z,w,u +#else +#define MYVOID +#define ARG_I(x) +#define ARG_II(x,y) +#define ARG_III(x,y,z) +#define ARG_IV(x,y,z,w) +#define ARG_V(x,y,z,w,u) +#endif + + +#if defined(DOS_WIN32) || defined(__DJGPP__) +#define dir_path_slash(str) (is_forward_slash(str)? '/' : '\\') +#else +#define dir_path_slash(str) '/' +#endif + + +struct htf_struct{ + Q_CHAR *key, *body; + struct htf_struct *next; +}; + + +struct empty_pic_struct{ + long int n; + struct empty_pic_struct *next; +}; + + +#ifndef HTFDIR +#define HTFDIR "" +#endif + + +struct files_rec{ + FILE* file; + char *name, *group, op; + Q_CHAR file_mode[5]; + int loc, label; + struct files_rec *from_rec, *right, *left, *down, *up; +}; +#define No_op 0 +#define From_op 1 +#define Until_op 2 +#define Skip_op 3 +#define Cont_op 4 +#define Addr_op 5 +#define Set_op 6 + + +struct env_c_rec{ + Q_CHAR *option; + struct env_c_rec *next; +}; + + +struct sys_call_rec{ + Q_CHAR * filter; + struct sys_call_rec *next; +}; + + +struct script_struct{ + Q_CHAR *command; + struct script_struct *next; +}; + + +#define NULL_SCRIPT (struct script_struct *) 0 + + +#define LG_EXT ".lg" + + +#define bad_arg err_arg(0) +#define bad_mem err_i(1) + + +#define eq_str(x,y) (!strcmp(x,y)) + + +#define m_alloc(typ,n) (typ *) malloc_chk((int) ((n) * sizeof(typ))) + + +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef BOOL +#define BOOL int +#endif + + +#define eq_str(x,y) (!strcmp(x,y)) + + + +static int eoln_ch; + + +static Q_CHAR *ch_mod = Q_NULL; +static Q_CHAR *debug = Q_NULL; +static Q_CHAR *Xfield = Q_NULL; +static Q_CHAR *Dotfield = Q_NULL; +static Q_CHAR *dir = Q_NULL; +static Q_CHAR *lg_name = Q_NULL, tmp_name[255], job_name[255]; +static Q_CHAR *nopict = Q_NULL; +static BOOL newchmod = FALSE; +static Q_CHAR *noreuse = Q_NULL; + + +U_CHAR *HOME_DIR; + + +static struct htf_struct *htf_rec = (struct htf_struct *) 0; + + +static struct env_c_rec *envChoice + = (struct env_c_rec*) 0; + + +static BOOL system_yes; +static struct sys_call_rec *system_calls = (struct sys_call_rec *) 0; + + +static BOOL status; + + +static char *Font_css_base = NULL, + *Font_css_mag = NULL; +static int base_font_size = 10; + + +static struct script_struct + * dvigif_script = NULL_SCRIPT, + * dvigif_glyp_script = NULL_SCRIPT, + * move_script = NULL_SCRIPT, + * empty_fig_script = NULL_SCRIPT, + * copy_script = NULL_SCRIPT, + * +file_script + + = NULL_SCRIPT, + * +ext_script + + = NULL_SCRIPT, + * chmod_script = NULL_SCRIPT; + + +static FILE* lg_file; +static long begin_lg_file; + + +static C_CHAR warning[] = "--- warning --- "; + + +static C_CHAR *warn_err_mssg[]={ + +"\n--------------------------------------------------------------------\n" +"t4ht [-f<dir char>]filename ...\n" +" -c... choose named segment in env file\n" +" -d... directory for output files (default: current)\n" +" -e... location of tex4ht.env\n" +" -i debugging info\n" +" -m... chmod ... of new output files (reused bitmaps excluded)\n" +" -p don't convert pictures (default: convert)\n" +" -r replace bitmaps of all glyphs (default: reuse old ones)\n" +" -M... chmod ... of all output files\n" +" -S... permission for system calls: *-always, filter\n" +" -X... content for field %%3 in X scripts\n" +" -.... content for field %%2 in . scripts\n\n" +"Example: \n" +" t4ht name -d/WWW/temp/ -etex4ht-32.env -m644\n" +"--------------------------------------------------------------------\n" + +, +"Insufficient memory\n", + +"Illegal storage address\n", +"Floating-point\n", +"Interrupt with Cntr-C\n", + + +"Can't find/open file `%s'\n", + + "" }; + + +static Q_CHAR command[255]; +static int system_return; + + +static BOOL system_yes; + + +static Q_CHAR* match[10]; +static int max_match[10]; + + + +#if defined(DOS_WIN32) || defined(__DJGPP__) + static BOOL is_forward_slash( ARG_I(Q_CHAR *) ); +#endif + + +static char * abs_addr( ARG_II( U_CHAR *, U_CHAR *) ); + + +static void execute_script( + ARG_V(struct script_struct*,Q_CHAR *,char *,Q_CHAR *,Q_CHAR *) ); + + +static struct script_struct * filterGifScript( + ARG_II( struct script_struct *, Q_CHAR *) ); + + +void free_script( + ARG_I( struct script_struct *) ); + + +static BOOL strpre( ARG_II(char *,char *) ); + + +static struct script_struct * add_script( ARG_I(struct script_struct *) ); + + +static FILE* f_open( ARG_II(char*,char*) ); + + +static FILE* f_home_open( ARG_II(char*,char*) ); + + +static FILE* open_file( ARG_II(C_CHAR *, C_CHAR *) ); + + +static void err_i( ARG_I(int) ); + + +static void err_arg( ARG_I(int) ); + + +static void warn_i_str( ARG_II(int,Q_CHAR *) ); + + +static void + +#ifdef CDECL +CDECL +#endif + + +sig_err(ARG_I(int)); + + +#ifdef KWIN32 +static BOOL sigint_handler(ARG_I(DWORD)); +#endif + + +static void call_sys(ARG_I(Q_CHAR *)); + + +static void strct( ARG_II(C_CHAR *, C_CHAR *) ); + + +static long int get_long_int( ARG_I(Q_CHAR *) ); + + +static void* malloc_chk(ARG_I(int)); + + +static void* r_alloc(ARG_II(void *, size_t)); + + +static BOOL scan_until_end_str( ARG_IV(C_CHAR *, int, BOOL, FILE *) ); + + +static BOOL scan_until_str( ARG_IV(C_CHAR *, int, BOOL, FILE *) ); + + +static BOOL scan_str( ARG_III(C_CHAR *, BOOL, FILE *) ); + + + +#if defined(DOS_WIN32) || defined(__DJGPP__) + +static BOOL is_forward_slash +#ifdef ANSI +#define SEP , +( + Q_CHAR * str +) +#undef SEP +#else +#define SEP ; +(str) + Q_CHAR * str +; +#undef SEP +#endif +{ + while( *str ){ if( *(str++) == '/' ) { return TRUE; } } + return FALSE; +} +#endif + + + +static char * abs_addr +#ifdef ANSI +#define SEP , +( + U_CHAR *dir SEP + U_CHAR *base + +) +#undef SEP +#else +#define SEP ; +( dir, base) + U_CHAR *dir SEP + U_CHAR *base + +; +#undef SEP +#endif +{ U_CHAR *p; + p = m_alloc(char, (int) strlen( dir ) + + (base? (int) strlen( base ):0) + + (int) strlen( HOME_DIR )); + *p = '\0'; + if( (*(dir+1) == '~') && base ){ + if( *base == '~' ){ + (IGNORED) strct(p, HOME_DIR); + (IGNORED) strct(p, base+1); + } else { + (IGNORED) strct(p, base); + } + (IGNORED) strct(p, dir+2); + } else { + (IGNORED) strct(p, HOME_DIR); + (IGNORED) strct(p, dir+1); + } + return p; +} + + + +static void execute_script +#ifdef ANSI +#define SEP , +( + struct script_struct* script SEP + Q_CHAR * match_1 SEP + Q_CHAR * match_2 SEP + Q_CHAR * match_3 SEP + Q_CHAR * match_4 + +) +#undef SEP +#else +#define SEP ; +(script,match_1,match_2,match_3,match_4) + struct script_struct* script SEP + Q_CHAR * match_1 SEP + Q_CHAR * match_2 SEP + Q_CHAR * match_3 SEP + Q_CHAR * match_4 + +; +#undef SEP +#endif +{ struct script_struct* temp; + Q_CHAR *p, *q, *t; + temp = script; system_return = 0; + while( temp ){ + +p = temp->command; +q = command; +while( *p != '\0' ){ + *q = *(p++); + if( (*q == '%') && (*p == '%') + && ((*(p+1) == '%') || ( (*(p+1) >= '0') && (*(p+1) < '5') ) ) + ){ p++; + switch( *(p++) ){ + case '%':{ q++; break; } + case '0':{ t = job_name; + while( *t != '\0' ){ *(q++) = *(t++); } break; } + case '1':{ t = match_1; + while( *t != '\0' ){ *(q++) = *(t++); } break; } + case '2':{ t = match_2; + while( *t != '\0' ){ *(q++) = *(t++); } break; } + case '3':{ t = match_3; + while( *t != '\0' ){ *(q++) = *(t++); } break; } + case '4':{ t = match_4; + while( *t != '\0' ){ *(q++) = *(t++); } break; } + default: { } + }} else { q++; } +} +*q = '\0'; + + + if( (command[0] != '\0') && !system_return ){ + +(IGNORED) call_sys(command); + + } + temp = temp->next; +} } + + + +static struct script_struct * filterGifScript +#ifdef ANSI +#define SEP , +( + struct script_struct *script SEP + Q_CHAR *file +) +#undef SEP +#else +#define SEP ; +( script, file) + struct script_struct *script SEP + Q_CHAR *file +; +#undef SEP +#endif +{ + struct script_struct *filtered_script, *scr, + *old_script, + *new_script; + Q_CHAR *command, *ext; + if( script == (struct script_struct *) 0 ){ + return (struct script_struct *) 0; + } + old_script = script; + command = old_script->command; + if( *command != '.' ){ + +new_script = (struct script_struct *) 0; +while( old_script != (struct script_struct *) 0 ){ + command = old_script->command; + if( *command == '.' ){ return filtered_script; } + scr = (struct script_struct *) + m_alloc(struct script_struct, (int) 1); + scr->command = old_script->command; + scr->next = (struct script_struct *) 0; + if( new_script == (struct script_struct *) 0 ){ + filtered_script = new_script = scr; + } else { + new_script = new_script->next = scr; + } + old_script = old_script->next; +} +return filtered_script; + + + } else { + + +ext = file; +while( *ext != '\0' ){ ext++; } +while( (*ext != '.') && (ext != file) ){ ext--; } + + +while( TRUE ){ + if( old_script == (struct script_struct *) 0 ){ + return (struct script_struct *) 0; + } + command = old_script->command; + if(*command != '.') { + old_script = old_script->next; + continue; + } + old_script = old_script->next; + if( (*(command+1) == '\0') || eq_str(ext,command) ){ + break; + } +} + +new_script = (struct script_struct *) 0; +while( old_script != (struct script_struct *) 0 ){ + command = old_script->command; + if( *command == '.' ){ return filtered_script; } + scr = (struct script_struct *) + m_alloc(struct script_struct, (int) 1); + scr->command = old_script->command; + scr->next = (struct script_struct *) 0; + if( new_script == (struct script_struct *) 0 ){ + filtered_script = new_script = scr; + } else { + new_script = new_script->next = scr; + } + old_script = old_script->next; +} +return filtered_script; + + + + + } +} + + + +void free_script +#ifdef ANSI +#define SEP , +( + struct script_struct *script +) +#undef SEP +#else +#define SEP ; +(script) + struct script_struct *script +; +#undef SEP +#endif +{ + struct script_struct *temp; + while( script != (struct script_struct *) 0 ){ + temp = script; + script = script->next; + free( temp ); + } +} + + + +static BOOL strpre +#ifdef ANSI +#define SEP , +( + char * s1 SEP + char * s2 +) +#undef SEP +#else +#define SEP ; +(s1,s2) + char * s1 SEP + char * s2 +; +#undef SEP +#endif +{ int i; + for( i=0; i < (int) strlen(s1); i++){ + if( *(s1+i) != *(s2+i) ){ return FALSE; } + } + return TRUE; +} + + + +static struct script_struct * add_script +#ifdef ANSI +#define SEP , +( + struct script_struct * script +) +#undef SEP +#else +#define SEP ; +(script) + struct script_struct * script +; +#undef SEP +#endif +{ + struct script_struct* temp, * q; + temp = (struct script_struct *) + m_alloc(struct script_struct, (int) 1); + temp->command = match[1]; + if( debug ){ + (IGNORED) printf("....... %s\n", temp->command); } + temp->next = NULL_SCRIPT; + match[1] = (Q_CHAR *) malloc(70); + max_match[1] = 70; + if( script ){ + q = script; + while( q->next ){ q = q->next; } + q->next = temp; + } else { + script = temp; + } + return script; +} + + +#if defined(DOS_WIN32) || defined(__MSDOS__) + + +char *get_env_dir +#ifdef ANSI +#define SEP , +( + Q_CHAR *progname + +) +#undef SEP +#else +#define SEP ; +(progname) + Q_CHAR *progname + +; +#undef SEP +#endif +{ int i; + Q_CHAR *p; + if(! progname || ! *progname) return NULL; + i = (int) strlen(progname); + while( (progname[--i] != dir_path_slash(progname) ) + && i > 0) ; + if(i == 0) return NULL; + p = (Q_CHAR *) malloc(i+12); + if(p == NULL) return NULL; + strncpy(p, progname, i+1); + (IGNORED) strcpy(&p[i+1],"tex4ht.env"); + return p; +} + + +#endif + + + +static FILE* f_open +#ifdef ANSI +#define SEP , +( + char* name SEP + char* flags +) +#undef SEP +#else +#define SEP ; +( name, flags ) + char* name SEP + char* flags +; +#undef SEP +#endif +{ FILE* file; + if( (file = fopen(name,flags) ) != NULL ) { + (IGNORED) printf("(%s)\n",name); + } + return file; +} + + + +static FILE* f_home_open +#ifdef ANSI +#define SEP , +( + char* name SEP + char* flags +) +#undef SEP +#else +#define SEP ; +( name, flags ) + char* name SEP + char* flags +; +#undef SEP +#endif +{ FILE* file; + U_CHAR *str; + if( *name == '~' ){ + if( HOME_DIR ){ + str = m_alloc(char, strlen(HOME_DIR)+strlen(name)); + (IGNORED) sprintf(str,"%s%s", HOME_DIR, name+1); + file = f_open(str,flags); + free((void *) str); + return file; + } else { return NULL; } + } else { return f_open( name, flags ); } +} + + + +static FILE* open_file +#ifdef ANSI +#define SEP , +( + Q_CHAR *name SEP Q_CHAR *ext +) +#undef SEP +#else +#define SEP ; +(name,ext) + Q_CHAR *name SEP Q_CHAR *ext +; +#undef SEP +#endif +{ FILE* file; + C_CHAR filename[255], *p; + if( eq_str( ext,LG_EXT ) ) { + (IGNORED) strcpy(filename,job_name); + (IGNORED) strct(filename, ext); + } else { + (IGNORED) strcpy( filename,name ); + p = filename; + while( TRUE ){ + if( *p == '.' ){ break; } + if( *p == '\0' ){ (IGNORED) strcpy(p, ext); break; } + p++; + } + } + file = fopen(filename, READ_TEXT_FLAGS); + if( !file ) { + (IGNORED) warn_i_str(5,filename); + } else { (IGNORED) printf ("Entering %s\n", filename); } + + return file; +} + + + +static void err_i +#ifdef ANSI +#define SEP , +( int n + +) +#undef SEP +#else +#define SEP ; +(n) int n + +; +#undef SEP +#endif +{ (IGNORED) fprintf(stderr,"--- error --- "); + (IGNORED) fprintf(stderr, warn_err_mssg[n]); + exit(EXIT_FAILURE); +} + + + +static void err_arg +#ifdef ANSI +#define SEP , +( int n + +) +#undef SEP +#else +#define SEP ; +(n) int n + +; +#undef SEP +#endif +{ (IGNORED) fprintf(stderr,"--- error --- "); + (IGNORED) fprintf(stderr, warn_err_mssg[n]); + exit(EXIT_FAILURE); +} + + + +static void warn_i_str +#ifdef ANSI +#define SEP , +( + int n SEP + Q_CHAR *str + +) +#undef SEP +#else +#define SEP ; +(n,str) + int n SEP + Q_CHAR *str + +; +#undef SEP +#endif +{ (IGNORED) fprintf(stderr,warning); + (IGNORED) fprintf(stderr,warn_err_mssg[n], str); +} + + + +static void + +#ifdef CDECL +CDECL +#endif + + +sig_err +#ifdef ANSI +#define SEP , +( int s +) +#undef SEP +#else +#define SEP ; +(s) int s +; +#undef SEP +#endif +{ + (void) signal(s,SIG_IGN); + switch( s ){ +#ifdef SIGSEGV + case SIGSEGV: err_i(2); +#endif + case SIGFPE : err_i(3); +#if defined(SIGINT) && !defined(WIN32) + case SIGINT : err_i(4); +#endif + } + +#ifdef __DJGPP__ + if (s != SIGINT && s != SIGQUIT) + exit(EXIT_FAILURE); +#endif + + +} + + +#ifdef KWIN32 + +static BOOL sigint_handler +#ifdef ANSI +#define SEP , +( DWORD dwCtrlType +) +#undef SEP +#else +#define SEP ; +(dwCtrlType) DWORD dwCtrlType +; +#undef SEP +#endif +{ + err_i(32); + return FALSE; +} +#endif + + + +static void call_sys +#ifdef ANSI +#define SEP , +( Q_CHAR * command +) +#undef SEP +#else +#define SEP ; +(command) Q_CHAR * command +; +#undef SEP +#endif +{ + if( *command ){ + (IGNORED) printf("System call: %s\n", command); + system_return = system_yes? (int) system(command) : -1; + (IGNORED) printf("%sSystem return: %d\n", + system_return? "--- Warning --- " : "", system_return ); + } +} + + + +static void strct +#ifdef ANSI +#define SEP , +( + Q_CHAR * str1 SEP + Q_CHAR * str2 + +) +#undef SEP +#else +#define SEP ; +( str1, str2 ) + Q_CHAR * str1 SEP + Q_CHAR * str2 + +; +#undef SEP +#endif +{ Q_CHAR * ch; + ch = str1 + (int) strlen(str1); + (IGNORED) strcpy( ch, str2 ); +} + + + +static long int get_long_int +#ifdef ANSI +#define SEP , +( + Q_CHAR *str +) +#undef SEP +#else +#define SEP ; +(str) + Q_CHAR *str +; +#undef SEP +#endif +{ long int i; + Q_CHAR *ch; + ch = str; i = 0; + while( (*ch>= '0') && (*ch <='9') ){ + i = 10*i + *(ch++) - '0'; + } + return i; +} + + + +static void* malloc_chk +#ifdef ANSI +#define SEP , +( int n +) +#undef SEP +#else +#define SEP ; +( n ) int n +; +#undef SEP +#endif +{ void* p; + if((p = (void *) malloc( (size_t) n)) == NULL ) bad_mem; + return p; +} + + + +static void* r_alloc +#ifdef ANSI +#define SEP , +( + void *q SEP + size_t n +) +#undef SEP +#else +#define SEP ; +( q, n ) + void *q SEP + size_t n +; +#undef SEP +#endif +{ void* p; + if((p = (void *) realloc( q, (size_t) n)) == NULL) bad_mem; + return p; +} + + + +static BOOL scan_until_end_str +#ifdef ANSI +#define SEP , +( + Q_CHAR *str SEP + int n SEP + BOOL flag SEP + FILE* file +) +#undef SEP +#else +#define SEP ; +(str,n,flag,file) + Q_CHAR *str SEP + int n SEP + BOOL flag SEP + FILE* file +; +#undef SEP +#endif +{ Q_CHAR *p; + int i; + if( !flag ) { return flag; } + p = match[n]; i = 0; + while( TRUE ){ + if( (i+1) >= max_match[n] ){ + max_match[n] += 10; + p = match[n] = (Q_CHAR *) + r_alloc((void *) match[n], (size_t) max_match[n]); + } + p[i] = (char) (eoln_ch = getc(file)); + if( (eoln_ch == (int) '\n') || (eoln_ch == EOF) ){ break; } + i++; + } + p[i] = '\0'; + i -= (int) strlen(str); + if( i>= 0 ){ return eq_str(p+i,str); } + return FALSE; +} + + + +static BOOL scan_until_str +#ifdef ANSI +#define SEP , +( + Q_CHAR *str SEP + int n SEP + BOOL flag SEP + FILE* file +) +#undef SEP +#else +#define SEP ; +(str,n,flag,file) + Q_CHAR *str SEP + int n SEP + BOOL flag SEP + FILE* file +; +#undef SEP +#endif +{ Q_CHAR *p, ch; + int i, j; + if( !flag ) { return flag; } + p = match[n]; i = 0; + while( TRUE ){ + ch = (char) (eoln_ch = getc(file)); + if( (eoln_ch == (int) '\n') || (eoln_ch == EOF) ){ return FALSE; } + if( (i+1) >= max_match[n] ){ + max_match[n] += 10; + p = match[n] = (Q_CHAR *) + r_alloc((void *) match[n], (size_t) max_match[n]); + } + p[i++] = ch; + j = i - (int) strlen(str); + if( j>= 0 ){ + p[i] = '\0'; + if( eq_str(p+j,str) ) { return TRUE; } + } + } +} + + + +static BOOL scan_str +#ifdef ANSI +#define SEP , +( + Q_CHAR *str SEP + BOOL flag SEP + FILE* file +) +#undef SEP +#else +#define SEP ; +(str,flag,file) + Q_CHAR *str SEP + BOOL flag SEP + FILE* file +; +#undef SEP +#endif +{ Q_CHAR *p; + int temp_eoln_ch; + if( !flag ) { return flag; } + p = str; + while( *p != '\0' ){ + if( *(p++) != (temp_eoln_ch = getc(file)) ) { + while( (temp_eoln_ch != (int) '\n') + && (temp_eoln_ch != EOF) ){ temp_eoln_ch = getc(file); } + eoln_ch = temp_eoln_ch; return FALSE; + } + } + return TRUE; +} + + + +int +#ifdef CDECL +CDECL +#endif + + main +#ifdef ANSI +#define SEP , +( + int argc SEP + Q_CHAR **argv +) +#undef SEP +#else +#define SEP ; +(argc, argv) + int argc SEP + Q_CHAR **argv +; +#undef SEP +#endif +{ +struct empty_pic_struct *empty_pic; + + +Q_CHAR * tex4ht_env_file = (Q_CHAR *) 0; +Q_CHAR * dos_env_file = +#if defined(DOS_WIN32) || defined(__MSDOS__) + +get_env_dir(argv[0]) + +; +#endif +#if !defined(DOS_WIN32) && !defined(__MSDOS__) + (Q_CHAR *) 0; +#endif + + + + + +#ifdef SIGSEGV + (void) signal(SIGSEGV,sig_err); +#endif + (void) signal(SIGFPE,sig_err); +#ifdef KWIN32 + +SetConsoleCtrlHandler((PHANDLER_ROUTINE)sigint_handler, TRUE); + + +#else +#ifdef SIGINT + (void) signal(SIGINT,sig_err); +#endif +#endif + + + +(IGNORED) printf("----------------------------\n"); +#ifndef KPATHSEA +#ifdef PLATFORM + (IGNORED) printf("t4ht.c (2005-08-04-07:03 %s)\n",PLATFORM); +#else + (IGNORED) printf("t4ht.c (2005-08-04-07:03)\n"); +#endif +#else +#ifdef PLATFORM + (IGNORED) printf("t4ht.c (2005-08-04-07:03 %s kpathsea)\n",PLATFORM); +#else + (IGNORED) printf("t4ht.c (2005-08-04-07:03 kpathsea)\n"); +#endif +#endif + +{ int i; + for(i=0; i<argc; i++){ + (IGNORED) printf("%s%s ", (i>1)?"\n " : "", argv[i]); } + (IGNORED) printf("\n"); +} + + + +HOME_DIR = getenv("HOME"); + + +{ C_CHAR *yes = NULL; + system_yes = ( +#ifdef SYSTEM_FUNCTION_OK +0 +#else +system( yes ) != 0 +#endif + +); +} + + +{ int i; + for( i=0; i<=9; i++){ + match[i] = (Q_CHAR *) malloc(70); + max_match[i] = 70; + } +} + + + + +{ int i; + Q_CHAR *p, *q; + +#ifdef KPATHSEA + kpse_set_program_name (argv[0], NULL); +#endif + + + + if( argc == 1 ){ bad_arg; } + for(i=1; i<argc; i++){ + if( *( p=argv[i] ) == '-' ){ +if( (int) strlen( argv[i] ) == 2 ){ + if( (*(p+1)!='i') && (*(p+1) != 'p') && (*(p+1) != 'r') ) + { if( ++i == argc ) bad_arg; } + q = argv[i]; +} else q = p+2; +switch( *(p+1) ){ + case 'M':{ ch_mod = q; newchmod = TRUE; break; } + case 'S':{ +{ struct sys_call_rec *q; + q = m_alloc(struct sys_call_rec, 1); + q->next = system_calls; + q->filter = p + 2; + system_calls = q; +} + + break; } + case 'X':{ Xfield = q; break;} + case 'c':{ +struct env_c_rec *temp = (struct env_c_rec*) + m_alloc(struct env_c_rec, (int) 1); +temp->option = q; +temp->next = envChoice; +envChoice = temp; + + break;} + case 'd':{ dir = (*q=='~')? abs_addr(q,NULL) : q; break; } + case 'e':{ +tex4ht_env_file = q; + + break; } + case 'f':{ +p = p + 2; +lg_name = p + (int) strlen( p ); +while( *lg_name != *p ){ lg_name--; } +lg_name++; + + break; } + case 'i':{ debug = q-1; break;} + case 'm':{ ch_mod = q; break; } + case 'p':{ nopict = q-1; break;} + case 'r':{ noreuse = q-1; break;} + case '.':{ Dotfield = q; break;} + default:{ bad_arg; } +} + + } + else + { lg_name = argv[i]; } + } + if( lg_name == NULL ){ bad_arg; } + +{ Q_CHAR *p, *q; + FILE* file; + (IGNORED) strcpy( tmp_name, lg_name); + p = q = tmp_name + strlen( tmp_name ); + while( p != tmp_name ){ + if( *p == '.' ){ + if( eq_str( p+1,LG_EXT ) ) { *p = '\0'; } + else { + (IGNORED) strct( tmp_name, LG_EXT); + file = fopen( tmp_name, READ_TEXT_FLAGS ); + if( file ){ + (IGNORED) fclose(file); *q = '\0'; + } else { *p = '\0'; } + } + break; + } + p--; + } + (IGNORED) strct(tmp_name, ".tmp"); +} + + + +(IGNORED) strcpy( job_name, tmp_name); +*(job_name + strlen(job_name) - 4) = '\0'; + + +} + + + + +{ FILE* file; + U_CHAR env_loc[512]; + env_loc[0] = '\0'; + +{ Q_CHAR str[512], + *TEX4HTENV; + +if( tex4ht_env_file ){ + if( debug ){ + (IGNORED) printf("%s?\n", tex4ht_env_file); + } + file = f_home_open( tex4ht_env_file, READ_TEXT_FLAGS ); +} else { + file = NULL; +} +if( tex4ht_env_file ){ + (IGNORED) strcpy(&env_loc[0],tex4ht_env_file); +} +if( debug && file ){ + (IGNORED) printf(".......Open: %s\n", tex4ht_env_file); } + + + +if( !file ) { + if( debug ){ + (IGNORED) printf("tex4ht.env?\n"); + } + file = f_open("tex4ht.env", READ_TEXT_FLAGS); + (IGNORED) strcpy(&env_loc[0],"tex4ht.env"); + if( debug && file ){ + (IGNORED) printf(".......Open: ./tex4ht.env\n"); } +} + + + +#ifndef DOS_WIN32 + if( !file ) { + if( debug ){ + (IGNORED) printf(".tex4ht?\n"); + } + file = f_open(".tex4ht", READ_TEXT_FLAGS); + (IGNORED) strcpy(&env_loc[0],".tex4ht"); + if( debug && file ){ + (IGNORED) printf(".......Open: ./.tex4ht\n"); } + } +#endif + + + +if( !file ){ + TEX4HTENV = getenv("TEX4HTENV"); + if( TEX4HTENV ){ + if( debug ){ + (IGNORED) printf("%s?\n", TEX4HTENV); + } + file = f_home_open(TEX4HTENV,READ_TEXT_FLAGS); + } +} + + + +if( !file ){ + if( HOME_DIR ){ (IGNORED) sprintf(str, +#if defined(DOS_WIN32) || defined(__DJGPP__) + is_forward_slash(HOME_DIR)? "%s/tex4ht.env" : "%s\\tex4ht.env" +#else + "%s/tex4ht.env" +#endif + +, HOME_DIR); + if( debug ){ + (IGNORED) printf("%s?\n", str); + } + file = f_open(str,READ_TEXT_FLAGS); + (IGNORED) strcpy(&env_loc[0],str); + if( debug && file ){ + (IGNORED) printf(".......Open: %s\n", str); } + } +} +#ifndef DOS_WIN32 + if( !file ){ + if( HOME_DIR ){ + (IGNORED) sprintf(str,"%s/.tex4ht", HOME_DIR); + if( debug ){ + (IGNORED) printf("%s?\n", str); + } + file = f_open(str,READ_TEXT_FLAGS); + (IGNORED) strcpy(&env_loc[0],str); + if( debug && file ){ + (IGNORED) printf(".......Open: %s\n", str); } + } + } +#endif +#if defined(DOS_WIN32) || defined(__MSDOS__) + if( !file ){ + if( debug ){ + (IGNORED) printf("C:/tex4ht.env?\n"); + } + file = f_open("C:/tex4ht.env",READ_TEXT_FLAGS); + (IGNORED) strcpy(&env_loc[0],"C:/tex4ht.env"); + if( debug && file ){ + (IGNORED) printf(".......Open: C:/tex4ht.env\n"); } + } +#endif + + + +#ifdef ENVFILE + if( !file ) { + if( debug ){ + (IGNORED) printf("%s?\n", ENVFILE); + } + file = f_home_open( ENVFILE,READ_TEXT_FLAGS); + (IGNORED) strcpy(&env_loc[0],ENVFILE); + if( debug && file ){ + (IGNORED) printf(".......Open: %s\n", ENVFILE); } + } +#endif + + + if( !file ) { +if( dos_env_file ){ + if( debug ){ + (IGNORED) printf("%s?\n", dos_env_file); + } + file = f_open( dos_env_file, READ_TEXT_FLAGS ) ; + (IGNORED) strcpy(&env_loc[0],dos_env_file); + if( debug && file ){ + (IGNORED) printf(".......Open: %s\n", dos_env_file); } +} + + } + + +#ifdef KPATHSEA +if( !file ) { U_CHAR * envname; + char *arch, *p, str[256]; + +p = arch = (char *) kpse_var_value( "SELFAUTOLOC" ); +while( *p != '\0' ){ + if( (*p == '/') || (*p == '\\') ){ + arch = p; + } + p++; +} + + + envname = (char *) 0; + +if( arch ){ + (IGNORED) sprintf(str,"%s%ctex4ht.env", arch+1, *arch); + if( debug ){ + (IGNORED) printf( + "kpse_open_file (\"%s\", kpse_program_text_format)?\n", str ); + } + envname= kpse_find_file (str, kpse_program_text_format, 0); +} + + + if ( !envname ){ +if( debug ){ + (IGNORED) printf( + "kpse_open_file (\"tex4ht.env\", kpse_program_text_format)?\n"); +} +envname= kpse_find_file ("tex4ht.env", kpse_program_text_format, 0); + + } + if ( envname ){ + file = kpse_open_file (envname, kpse_program_text_format); + (IGNORED) printf("(%s)\n", envname); + } + if( debug && file ){ + (IGNORED) printf(".......Open kpathsea %s\n", envname); + } +} +if( debug ){ + U_CHAR *p, *q; + +p = (U_CHAR *) kpse_var_value( "T4HTINPUTS" ); +if( p ){ + (IGNORED) printf("T4HTINPUTS = %s\n", p); +} +q = getenv("T4HTINPUTS"); +if( q ){ (IGNORED) printf( + "Environmet var T4HTINPUTS: %s\n", q); +} +if( !p && !q ){ + (IGNORED) printf( "Missing T4HTINPUTS for kpathsea\n" ); +} + + +} +#endif + + + if( !file ) warn_i_str( 5, +#ifdef DOS_WIN32 + "tex4ht.env" +#endif +#ifndef DOS_WIN32 + "tex4ht.env | .tex4ht" +#endif + +); +} + + + if( file ){ + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { Q_CHAR ch; + ch = (char) (eoln_ch = getc(file)); + if( eoln_ch != (int) '\n' ){ + status = scan_until_end_str("", 1, TRUE, file); + if( status ){ + switch( ch ){ + case 'A':{ +if( debug ){ + (IGNORED) printf(".......'A' script\n"); } +chmod_script = add_script(chmod_script); + + break;} + case 'C':{ +if( debug ){ + (IGNORED) printf(".......'C' script\n"); } +copy_script = add_script(copy_script); + + break;} + case 'E':{ +if( debug ){ + (IGNORED) printf(".......'E' script\n"); } +empty_fig_script = add_script(empty_fig_script); + + break;} + case 'F':{ +if( debug ){ + (IGNORED) printf(".......'F' script\n"); } +dvigif_glyp_script = add_script(dvigif_glyp_script); + + break;} + case 'G':{ +if( debug ){ (IGNORED) printf(".......'G' script\n"); } +dvigif_script = add_script(dvigif_script); + + break;} + case 'M':{ +if( debug ){ + (IGNORED) printf(".......'M' script\n"); } +move_script = add_script(move_script); + + break;} + case 'S':{ +{ struct sys_call_rec *q; + q = m_alloc(struct sys_call_rec, 1); + q->next = system_calls; + q->filter = match[1]; + match[1] = (Q_CHAR *) malloc(70); max_match[1] = 70; + system_calls = q; +if( debug ){ + (IGNORED) printf(".......'S' script: '%s'\n", + q->filter); } +} + + break;} + case 'X':{ +if( debug ){ + (IGNORED) printf(".......'X' script\n"); } + +file_script + + = add_script( +file_script + +); + + break;} + case '.':{ +if( debug ){ + (IGNORED) printf(".......'.' script\n"); } + +ext_script + + = add_script( +ext_script + +); + + break;} + case '<':{ +if( *(match[1]) != '/' ){ + U_CHAR *p; + BOOL env_skip; + for( p = match[1]; + (*p != '>') && (*p != '\n') && (*p != EOF ) ; + p++ ){} + if( *p == '>' ){ *p = '\0'; } + +if( envChoice == (struct env_c_rec*) 0 ){ + env_skip = !eq_str(match[1], "default" ); +} else { + struct env_c_rec *p; + env_skip = TRUE; + for( p=envChoice; p!=(struct env_c_rec*) 0 ; p = p->next ){ + if( eq_str(match[1], p->option ) ){ env_skip = FALSE; } +} } + + + if( env_skip ){ + + U_CHAR cur_block[90]; +if( debug ){ + (IGNORED) printf("....... <%s> skipping ...\n", match[1]); +} +(IGNORED) strcpy( cur_block, match[1]); +status = FALSE; +while( !status && (eoln_ch != EOF) ){ + status = scan_str("</", TRUE, file); + status = scan_until_str(">", 1, status, file); + status = scan_until_end_str("", 2, status, file); + if( status ){ + *(match[1] + strlen(match[1]) - 1) = '\0'; + status = eq_str(match[1], cur_block); + if( debug ){ + (IGNORED) printf("....... </%s>\n", match[1]); +} } } + + + } else { + if( debug ){ + (IGNORED) printf("....... <%s>\n", match[1]); + } + } +} else if( debug ){ + (IGNORED) printf("....... <%s\n", match[1]); +} + + break;} + default:{ } +} } } } + + + (IGNORED) fclose(file); +} } + + +lg_file = open_file(lg_name,LG_EXT); +if( lg_file ) { + +begin_lg_file = ftell(lg_file); + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +{ +Q_CHAR *file_name, file_mode[5]; +int i, start_loc, end_loc, addr; +char rec_op, *ch; +static struct files_rec *to_rec, *from_rec, + *opened_files = (struct files_rec *) 0, + *p, *p1, *p2, *p3, *p4, *from_op, *to_op; +FILE *in_file, *out_file; +BOOL write_on; + + + eoln_ch = (int) 'x'; + while( eoln_ch != EOF ) { + status = scan_str("CopyTo: ", TRUE, lg_file); + status = scan_until_str(" ", 1, status, lg_file); + status = scan_until_str(" ", 2, status, lg_file); + status = scan_until_str(" ", 3, status, lg_file); + status = scan_until_str(" ", 4, status, lg_file); + status = scan_until_end_str("", 5, status, lg_file); + if( status ){ + if( debug ){ + (IGNORED) printf("...CopyTo: %s%s%s%s%s...\n", + match[1], match[2], match[3], match[4], match[5]); + } + rec_op = eq_str(match[2],"From ")? From_op : + ( eq_str(match[2],"Until ")? Until_op : + ( eq_str(match[2],"Skip ")? Skip_op : + ( eq_str(match[2],"Cont ")? Cont_op : No_op ))); + if( rec_op == No_op ){ +ch = match[2]; +if( (ch[0]=='S') && (ch[1]=='e') && (ch[2]=='t') ){ + ch += 3; rec_op = Set_op; +} else if( (ch[0]=='A') && (ch[1]=='d') && (ch[2]=='d') && (ch[3]=='r') ){ + ch += 4; rec_op = Addr_op; +} +if( rec_op != No_op ){ + addr = 0; while( (*ch>='0') && (*ch<='9') ){ + addr = addr*10 + *ch - '0'; ch++; +} } + + } + if( rec_op == No_op ){ + (IGNORED) fprintf(stderr,warning); + (IGNORED) fprintf(stderr,"CopyTo: %s%s%s%s%s?\n", + match[1], match[2], match[3], match[4], match[5]); + } else { + +file_name = match[1]; +*(file_name + (int) strlen(file_name) - 1) = '\0'; +strcpy(file_mode, WRITE_TEXT_FLAGS); +for(i=1; i<=2; i++){ + +for( p = opened_files; p != (struct files_rec*) 0; p = p->right ){ + if( eq_str(file_name,p->name) ) { break; } +} +if( p == (struct files_rec*) 0 ){ + p = m_alloc(struct files_rec, 1); + p->right = opened_files; opened_files = p; + p->down = (struct files_rec*) 0; + strcpy(p->file_mode,file_mode); + p->name = m_alloc(char, (int) strlen(file_name) + 1); + (IGNORED) strcpy( p->name, file_name ); + if( (p->file = fopen(file_name, file_mode)) == NULL ) + { (IGNORED) warn_i_str(5,file_name); } +} +to_rec = from_rec; from_rec = p; + + + file_name = match[5]; + strcpy(file_mode, +READ_BIN_FLAGS + +); +} + + + +if( to_rec->down == (struct files_rec*) 0 ){ + +to_rec->down = p = m_alloc(struct files_rec, 1); +p->up = to_rec; +p->right = p->left = p->down = (struct files_rec*) 0; +p->name = to_rec->name; +p->file = to_rec->file; +p->from_rec = from_rec; +p->loc = -1; +p->op = No_op; +to_rec = p; + + +} else { + to_rec = to_rec->down; + for( p = to_rec->right; p != (struct files_rec*) 0; p = p->right ){ + if( to_rec->from_rec == from_rec ){ break; } + to_rec = p; + } + if( to_rec->from_rec != from_rec ){ + +to_rec->right = p = m_alloc(struct files_rec, 1); +p->left = to_rec; +p->right = p->down = (struct files_rec*) 0; +p->up = to_rec->up; +p->name = to_rec->name; +p->file = to_rec->file; +p->from_rec = from_rec; +p->loc = -1; +to_rec = p; + + +} } + + + +if( to_rec->down == (struct files_rec*) 0 ){ + +to_rec->down = p = m_alloc(struct files_rec, 1); +p->up = to_rec; +p->right = p->left = p->down = (struct files_rec*) 0; +p->name = to_rec->name; +p->file = to_rec->file; +p->from_rec = from_rec; +p->loc = -1; +p->op = No_op; +p->group = m_alloc(char, (int) strlen(match[3]) + 1); +(IGNORED) strcpy( p->group, match[3] ); +to_rec = p; + + +} else { + to_rec = to_rec->down; + for( p = to_rec->right; p != (struct files_rec*) 0; p = p->right ){ + if( eq_str(to_rec->group,match[3]) ){ break; } + to_rec = p; + } + if( !eq_str(to_rec->group,match[3]) ){ + +to_rec->right = p = m_alloc(struct files_rec, 1); +p->left = to_rec; +p->right = p->down = (struct files_rec*) 0; +p->up = to_rec->up; +p->name = to_rec->name; +p->file = to_rec->file; +p->from_rec = from_rec; +p->loc = -1; +p->group = m_alloc(char, (int) strlen(match[3]) + 1); +(IGNORED) strcpy( p->group, match[3] ); +to_rec = p; + + +} } + + + +p = m_alloc(struct files_rec, 1); +p->down = to_rec->down; to_rec->down = p; +p->up = to_rec; +if( p->down != (struct files_rec*) 0 ){ + (p->down)->up = p; +} +*(match[4] + (int) strlen(match[4]) - 1) = '\0'; +p->loc = (int) get_long_int(match[4]); +p->op = rec_op; +p->label = addr; + + + +if( rec_op == Until_op ){ + for( to_op = p = to_rec->down; + p != (struct files_rec*) 0; p = p->down ){ + if( p->op == From_op ){ from_op = p; break; } + } + if( p == (struct files_rec*) 0 ){ + +(IGNORED) fprintf(stderr,"%sMissing `CopyTo From':\n", warning); +for( p = to_rec->down; p != (struct files_rec*) 0; p = p->down ){ + (IGNORED) fprintf(stderr," %s %s%d %s\n", to_rec->name, + p->op == From_op ? "From " : + ( p->op == Until_op ? "Until " : + ( p->op == Skip_op ? "Skip " : + ( p->op == Cont_op? "Cont " : + ( p->op == Addr_op? "Addr " : + ( p->op == Set_op? "Set " : "No_op " ))))), + p->loc, from_rec->name + ); +} + + + } else { + +in_file = from_rec->file; +out_file = to_rec->file; +start_loc = from_op->loc; +write_on = TRUE; +(IGNORED) fseek(in_file, (long) start_loc, +0 +); +for( p= from_op; p != to_rec; p = p->up ){ + switch( p->op ){ + case Until_op:{ +if( write_on ){ + end_loc = p->loc; + for(; start_loc<end_loc; start_loc++) { + (IGNORED) putc( getc(in_file), out_file ); +} } + + break; } + case Skip_op:{ +if( write_on ){ + end_loc = p->loc; + for(; start_loc<end_loc; start_loc++) { + (IGNORED) putc( getc(in_file), out_file ); + } +} +write_on = FALSE; + + break; } + case Cont_op:{ +end_loc = p->loc; +if( write_on ){ + for(; start_loc<end_loc; start_loc++) { + (IGNORED) putc( getc(in_file), out_file ); + } +} else { + start_loc = end_loc; + (IGNORED) fseek(in_file, (long) end_loc, +0 +); +} +write_on = TRUE; + + break; } + case Set_op:{ +addr = -1; +for( p1 = from_op->up; p1 != to_rec; p1 = p1->up ){ + if( (p1->op == Addr_op) && (p1->label == p->label) ){ + addr = p1->loc; break; +} } +if( addr != -1 ){ (p->up)->loc = addr; } + + break; } + default: { } +} } + + + +to_rec->down = from_op->down; +if( from_op->down != (struct files_rec*) 0){ + (from_op->down)->up = to_rec; +} +for( p = from_op; p != to_rec; ){ + p1 = p; p = p->up; free((void *) p1); +} +if( to_rec->down == (struct files_rec*) 0){ + if( to_rec->left == (struct files_rec*) 0 ){ + (to_rec->up)->down = to_rec->right; + } else { + (to_rec->left)->right = to_rec->right; + } + if( to_rec->right != (struct files_rec*) 0 ){ + (to_rec->right)->left = to_rec->left; + } + p1 = to_rec; to_rec = to_rec->up; free((void *) p1); +} + + + } +} + + + } } } + +for( p = opened_files; p != (struct files_rec*) 0; ){ + (IGNORED) fclose(p->file); + free((void *) p->name); + +for( p1 = p->down; p1 != (struct files_rec*) 0; ){ + +for( p2 = p1->down; p2 != (struct files_rec*) 0; ){ + +for( p3 = p2->down; p3 != (struct files_rec*) 0; ){ + p4 = p3; p3 = p3->down; free((void *) p4); +} + + + p3 = p2; p2 = p2->right; free((void *) p3); +} + + + p2 = p1; p1 = p1->right; free((void *) p2); +} + + + p1= p; p = p->right; free((void *) p1); +} + + +} + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +{ struct htf_struct *last_rec, *p; + last_rec = (struct htf_struct *) 0; + eoln_ch = (int) 'x'; + while( eoln_ch != EOF ) { + status = scan_str("htfcss: ", TRUE, lg_file); + status = scan_until_end_str("", 1, status, lg_file); + +if( status ){ + Q_CHAR *s, *t; + int i; + s = t = match[1]; + for( i=0; *s == ' '; s++ ) { i++; } + if( i>0 ){ + while( *s != 0 ){ + *(t++) = *(s++); + } + *t = 0; +} } + + + if( status ){ Q_CHAR *key, *body; + body = key = match[1]; + +while( *body && (*body != ' ') ){ body++; } +if( *body == ' ' ){ *(body++) = '\0'; } +if( *body ){ + if( *key ){ +p = m_alloc(struct htf_struct, 1); +p->next = (struct htf_struct *) 0; +p->key = m_alloc(char, (int) strlen(key) + 1); +(IGNORED) strcpy( p->key, key ); +p->body = m_alloc(char, (int) strlen(body) + 1); +(IGNORED) strcpy( p->body, body ); +if( last_rec ){ + last_rec->next = p; last_rec = p; +} else { + htf_rec = last_rec = p; +} +if( debug ){ + (IGNORED) printf(".......%s...%s\n", key, body); +} + + } + else if( last_rec ){ +last_rec->body = (Q_CHAR *) r_alloc((void *) last_rec->body, + (size_t) strlen(last_rec->body) + + (size_t) strlen(body) + + 2); +(IGNORED) strct(last_rec->body,"\n"); +(IGNORED) strct(last_rec->body,body); +if( debug ){ + (IGNORED) printf(".......%s\n", body); +} + + } +} + + + } } +} + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_str("Font_Css_Plus ", TRUE, lg_file); + status = scan_until_str(" ", 1, status, lg_file); + status = scan_until_end_str("", 2, status, lg_file); + if( status ){ Q_CHAR *key; + key = match[1]; + *(key + (int) strlen(key) - 1) = '\0'; + +if( (*key != '\0') && (*key != '\n') ) { + struct htf_struct *p; + p = m_alloc(struct htf_struct, 1); + p->next = htf_rec; + htf_rec = p; + p->key = m_alloc(char, (int) strlen(key) + 1); + (IGNORED) strcpy( p->key, key ); + p->body = m_alloc(char, (int) strlen(match[2]) + 1); + (IGNORED) strcpy( p->body, match[2] ); + if( debug ){ + (IGNORED) printf(".......%s...%s\n", key, match[2]); +} } + + +} } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +{ struct empty_pic_struct *last; + last = empty_pic = (struct empty_pic_struct *) 0; + while( TRUE ) { + status = scan_str("--- empty picture --- ", TRUE, lg_file); + status = scan_until_str( ".idv[" , 1, status, lg_file); + status = scan_until_end_str("] ---", 1, status, lg_file); + if( status ){ +if( last == (struct empty_pic_struct *) 0 ){ + last = empty_pic = (struct empty_pic_struct *) + m_alloc(struct empty_pic_struct, (int) 1); +} else { + last = last->next = (struct empty_pic_struct *) + m_alloc(struct empty_pic_struct, (int) 1); +} +last->next = (struct empty_pic_struct *) 0; +last->n = get_long_int(match[1]); + + } + if ( eoln_ch == EOF ){ break; } + } + +if( last == (struct empty_pic_struct *) 0 ){ + last = empty_pic = (struct empty_pic_struct *) + m_alloc(struct empty_pic_struct, (int) 1); +} else { + last = last->next = (struct empty_pic_struct *) + m_alloc(struct empty_pic_struct, (int) 1); +} +last->next = (struct empty_pic_struct *) 0; +last->n = get_long_int(match[1]); + + + last->next = (struct empty_pic_struct *) 0; + last->n = 100000; +} + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +{ BOOL characters, skip; + characters = skip = FALSE; + while( TRUE ) { + status = scan_until_str("--- ", 1, TRUE, lg_file); + status = scan_until_str( " ---" , 2, status, lg_file); + if( status ) { + if( eq_str(match[1],"--- ") ){ + if( eq_str(match[2],"needs ---") ){ + +status = scan_until_str(" ", 1, status, lg_file); +status = scan_until_str(".idv", 1, status, lg_file); +status = scan_until_str("[", 2, status, lg_file); +status = scan_until_str("] ==> ", 2, status, lg_file); +status = scan_until_str(" ", 3, status, lg_file); + *(match[3] + (int) strlen(match[3]) - 1) = '\0'; +status = scan_until_end_str("---", 4, status, lg_file); +if( status ) { + +struct script_struct + * filtered_dvigif_script = NULL_SCRIPT; + + + long int gif_i; + Q_CHAR *p; + gif_i = get_long_int(match[2]); + p = match[2]; + *(p + (int) strlen(p) - 6) = '\0'; + if( characters ){ + + Q_CHAR filename[255]; + FILE* file; +(IGNORED) strcpy(filename, ""); +if( dir ){ (IGNORED) strct(filename, dir); } +(IGNORED) strct(filename, match[3]); +file = fopen(filename, READ_TEXT_FLAGS); +if( !file || noreuse ){ + +filtered_dvigif_script = dvigif_glyp_script? + filterGifScript(dvigif_glyp_script, match[3]): + filterGifScript(dvigif_script, match[3]); +(void) execute_script( + filtered_dvigif_script,match[1],match[2],match[3],job_name); +(void) free_script( filtered_dvigif_script ); +if( dir && !system_return ){ + (void) execute_script(move_script,match[3],dir,".",""); + +if( ch_mod && !system_return ){ + (void) execute_script(chmod_script, ch_mod, dir?dir:"",match[3], ""); +} + + +} + + +} else { + (IGNORED) fclose(file); + if( newchmod ) + { +if( ch_mod && !system_return ){ + (void) execute_script(chmod_script, ch_mod, dir?dir:"",match[3], ""); +} + + } + (IGNORED) printf("%s already in %s\n", match[3], + dir? dir : "current directory" ); +} + + + } else { +if( gif_i == +empty_pic->n + + ) { + +if( !skip ){ + (void) execute_script(empty_fig_script, + dir? dir :"", match[3],"",""); + if( ch_mod && !system_return ){ + (void) execute_script(chmod_script, ch_mod, + dir?dir:"",match[3], ""); + } +} +empty_pic = empty_pic->next; + + +} else { +if( !nopict && !skip ){ + +filtered_dvigif_script = filterGifScript(dvigif_script, match[3]); +(void) execute_script( + filtered_dvigif_script,match[1],match[2],match[3],job_name); +(void) free_script( filtered_dvigif_script ); +if( dir && !system_return ){ + (void) execute_script(move_script,match[3],dir,".",""); +} +if( ch_mod && !system_return ){ + (void) execute_script(chmod_script, ch_mod, dir?dir:"",match[3], ""); +} + + +} + + } + + } +} + + + } else if( eq_str(match[2],"characters ---") ){ + +status = scan_until_end_str("", 1, status, lg_file); +characters = eq_str(match[1],""); + + + } else { +status = scan_until_end_str("", 1, status, lg_file); + + } + } else { +status = scan_until_end_str(" ignore ---", 2, status, lg_file); +if( status ){ + skip = eq_str(match[2]," ignore ---") ? TRUE : + ( eq_str(match[2]," end ignore ---") ? FALSE : skip ); +} + + } + } + if ( eoln_ch == EOF ){ break; } +} } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +{ + Q_CHAR css_name[255]; + FILE *css_file, *tmp_file; + BOOL css_sty; + +(IGNORED) strcpy( css_name, job_name); +(IGNORED) strct(css_name, ".css"); +css_file = fopen(css_name, READ_TEXT_FLAGS); + + + if( css_file ){ + (IGNORED) printf ("Entering %s\n", css_name); + tmp_file = fopen(tmp_name, WRITE_TEXT_FLAGS); + if( !tmp_file ) { + (IGNORED) warn_i_str(5,tmp_name); + } else { + int ch; +while( (ch = getc(css_file)) != EOF ) { + (IGNORED) putc( ch, tmp_file ); +} +(IGNORED) fclose(tmp_file); +(IGNORED) fclose(css_file); + + } + tmp_file = open_file(tmp_name, ".tmp"); + css_file = fopen(css_name, WRITE_TEXT_FLAGS); + if( !tmp_file ) { + (IGNORED) warn_i_str(5,tmp_name); + } else if( !css_file ) { + (IGNORED) warn_i_str(5,css_name); + } else { + +css_sty = FALSE; +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_until_end_str("", 1, TRUE, tmp_file); + +{ Q_CHAR *p, *q; + int n; + n = 0; p = match[1]; q = match[2]; + while ( (*p != '\0') ){ + if (n == 13) { *(q-10) = '\0'; break;} + if( *p != ' ' ){ *(q++) = *p; n++; } + p++; + } + *q = '\0'; +} + + + if( eq_str(match[2], "/*css.sty*/") ){ css_sty = TRUE; break; } + (IGNORED) fprintf(css_file, "%s\n", match[1]); +} + + + if( css_sty ){ + +(IGNORED) fprintf(css_file, "/* start css.sty */\n"); + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_str("Font_css_base: ", TRUE, lg_file); + status = scan_until_str("Font_css_mag: ", 1, status, lg_file); + status = scan_until_end_str("", 2, status, lg_file); + if( status ){ + Font_css_base = match[1]; + *(Font_css_base + (int) strlen(Font_css_base) - 14) = '\0'; + match[1] = (Q_CHAR *) malloc(70); max_match[1] = 70; + Font_css_mag = match[2]; + match[2] = (Q_CHAR *) malloc(70); max_match[2] = 70; +} } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_str("Font_Size: ", TRUE, lg_file); + status = scan_until_end_str("", 1, status, lg_file); + if( status ){ + base_font_size = (int) get_long_int(match[1]); +} } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_str("Font(\"", TRUE, lg_file); + status = scan_until_str("\",\"", 1, status, lg_file); + status = scan_until_str("\",\"", 2, status, lg_file); + status = scan_until_str("\",\"", 3, status, lg_file); + status = scan_until_end_str("\")", 4, status, lg_file); + if( status ){ + Q_CHAR *p; + struct htf_struct *font_sty; + int second; + p = match[1]; + *(p + (int) strlen(p) - 3) = '\0'; + p = match[2]; + *(p + (int) strlen(p) - 3) = '\0'; + p = match[3]; + *(p + (int) strlen(p) - 3) = '\0'; + p = match[4]; + *(p + (int) strlen(p) - 2) = '\0'; + +font_sty = htf_rec; +while ( font_sty ) { + if( eq_str(font_sty->key,match[1]) ){ break; } + font_sty = font_sty->next; +} + + + +{ Q_CHAR *p; + second = (int) + ( (int) get_long_int(match[3]) + * (int) get_long_int(match[4]) + / base_font_size + ); + while( second > 700 ){ second /= 10; } + p = match[3]; + while( *p != '\0' ){ + if( (*p < '0') || (*p > '9') ){ second = 100; break; } + p++; + } +} + + + if( font_sty || (second != 100) ){ + +(IGNORED) fprintf(css_file, + (Font_css_base == NULL)? ".%s-%s" : Font_css_base, + match[1], match[2]); +if( !eq_str(match[4],"100") ){ + (IGNORED) fprintf(css_file, + (Font_css_mag == NULL)? "x-x-%s" : Font_css_mag, + match[4]); +} +(IGNORED) fprintf(css_file, "{"); +if( (second < 98) || (second > 102) ){ + (IGNORED) fprintf(css_file, "font-size:%d%c;", second, '%'); +} +if( font_sty ) { + (IGNORED) fprintf(css_file, font_sty->body); +} +(IGNORED) fprintf(css_file, "}\n"); + + +} } } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +{ char *font_class [256]; + int last_class; + +last_class = 0; +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_str("Font_Class(", TRUE, lg_file); + status = scan_until_str(",\"", 1, status, lg_file); + status = scan_until_str("\"): ", 1, status, lg_file); + status = scan_until_end_str("", 2, status, lg_file); + if( status ){ + font_class[last_class++] = match[1]; + match[1] = (Q_CHAR *) malloc(7); max_match[1] = 7; +} } + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + + + + eoln_ch = (int) 'x'; + while( eoln_ch != EOF ) { + status = scan_str("Font_Css(\"", TRUE, lg_file); + status = scan_until_str("\"): ", 1, status, lg_file); + status = scan_until_end_str("", 2, status, lg_file); + if( status ){ int i; + for(i=0; i<last_class; i++){ + if( eq_str(match[1],font_class[i]) ){ + (IGNORED) fprintf(css_file, "%s\n", match[2]); + break; +} } } } } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_str("Css: ", TRUE, lg_file); + status = scan_until_end_str("", 1, status, lg_file); + if( status ){ + (IGNORED) fprintf(css_file, "%s\n", match[1]); +} } + + +(IGNORED) fprintf(css_file, "/* end css.sty */\n"); + + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_until_end_str("", 1, TRUE, tmp_file); + +{ Q_CHAR *p, *q; + int n; + n = 0; p = match[1]; q = match[2]; + while ( (*p != '\0') ){ + if (n == 13) { *(q-10) = '\0'; break;} + if( *p != ' ' ){ *(q++) = *p; n++; } + p++; + } + *q = '\0'; +} + + + if( !eq_str(match[2], "/*css.sty*/") ){ + (IGNORED) fprintf(css_file, "%s\n", match[1]); + } +} + + + } + } + (IGNORED) fclose(tmp_file); + (IGNORED) fclose(css_file); +} } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +if( +ext_script + + ){ + eoln_ch = (int) 'x'; + while( eoln_ch != EOF ) { + status = scan_str("File: ", TRUE, lg_file); + status = scan_until_str(".", 1, status, lg_file); + status = scan_until_end_str("", 2, status, lg_file); + if( status ){ Q_CHAR *ext; + struct script_struct *cur_script; + ext = match[1]; + (IGNORED) strct( ext, match[2] ); + ext += strlen(ext); + while( *(--ext) != '.' ){ ; } + *ext = '\0'; ext++; + +{ + struct script_struct *cur, *add, *temp; + Q_CHAR extPlus[256]; + cur = +ext_script + +; + add = cur_script = NULL_SCRIPT; + while( cur ){ + +(IGNORED) strcpy(extPlus, ext); +/* + if ( envChoice ) { + (IGNORED) strct ( extPlus, envChoice ); + } +*/ +(IGNORED) strct ( extPlus, " " ); + + + if( strpre(extPlus, cur->command) ){ + +temp = (struct script_struct *) + m_alloc(struct script_struct, (int) 1); +temp->command = m_alloc(char, (int) strlen(cur->command) + 1); +temp->next = NULL_SCRIPT; +(IGNORED) strcpy(temp->command, cur->command + (int) strlen(extPlus) ); + + + if( cur_script == NULL_SCRIPT ){ + cur_script = add = temp; + } else { + add = add->next = temp; + } } + cur = cur->next; +} } + + + (void) execute_script(cur_script, + match[1], Dotfield? Dotfield : "", "", ""); + +while( cur_script != (struct script_struct*) 0 ){ + struct script_struct *temp; + temp = cur_script; cur_script = cur_script->next; free((void *) temp); +} + + +} } } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +if( +file_script + + ){ + eoln_ch = (int) 'x'; + while( eoln_ch != EOF ) { + status = scan_str("File: ", TRUE, lg_file); + status = scan_until_str(".", 1, status, lg_file); + status = scan_until_end_str("", 2, status, lg_file); + if( status ){ Q_CHAR *p; + p = match[1]; + (IGNORED) strct( p, match[2] ); + p += strlen(p); + while( *(--p) != '.' ){ ; } + *p = '\0'; p++; + (void) execute_script(file_script, match[1], + p, Xfield? Xfield : "", ""); +} } } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { + status = scan_str("File: ", TRUE, lg_file); + status = scan_until_end_str("", 1, status, lg_file); + status = status && !eq_str(match[1],tmp_name); + if( status ){ + FILE* file; + file = fopen(match[1], READ_TEXT_FLAGS); + if( file ){ + (IGNORED) fclose(file); + } else { status = FALSE; } + } + if( status ){ + if( dir ){ + (void) execute_script(copy_script, match[1], + dir? dir :"",".",""); + } + if( ch_mod ){ + (void) execute_script(chmod_script, ch_mod, + dir? dir:"",match[1], ""); + } +} } + + + +(IGNORED) fseek(lg_file, begin_lg_file, +0 +); + + +eoln_ch = (int) 'x'; +while( eoln_ch != EOF ) { Q_CHAR *command, ch; + int n; + struct sys_call_rec *p; + BOOL flag; + status = scan_str("l. ", TRUE, lg_file); + status = scan_until_str(" --- needs --- \"", 1, status, lg_file); + status = scan_until_str("\" ---", 2, status, lg_file); + if( status ){ + command = match[2]; + *(command + (int) strlen(command) - 5) = '\0'; + +flag = FALSE; +p = system_calls; +while( p ){ + if( (n = (int) strlen(p->filter)) == 1 ) { + if( *(p->filter) == '*' ){ + flag = TRUE; break; + } + } + if( strlen(command) >= (unsigned int) n ) { + ch = command[n]; command[n] = '\0'; + flag = flag || eq_str(p->filter,command); + command[n] = ch; + } + p = p->next; +} + + + if( flag ){ + +(IGNORED) call_sys(command); + + + } else { (IGNORED) printf( + "No permission for system call: %s\n", command); } +} } + + + (IGNORED) fclose(lg_file); +} + + + return 0; +} + + |