diff options
Diffstat (limited to 'contrib/texmacs/src/tm_openaxiom.c')
| -rwxr-xr-x | contrib/texmacs/src/tm_openaxiom.c | 603 |
1 files changed, 603 insertions, 0 deletions
diff --git a/contrib/texmacs/src/tm_openaxiom.c b/contrib/texmacs/src/tm_openaxiom.c new file mode 100755 index 00000000..edad4f68 --- /dev/null +++ b/contrib/texmacs/src/tm_openaxiom.c @@ -0,0 +1,603 @@ +/* tm_openaxiom.c
+ * COPYRIGHT : (C) 2004 Bill Page <bill.page1@sympatico.ca>
+ * (Portions) COPYRIGHT : (C) 1999 Andrey Grozin
+ ***********************************************************************
+ * This software falls under the GNU general public license and comes
+ * WITHOUT ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE
+ * for more details. If you don't have this file, write to the Free
+ * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ ***********************************************************************
+ *
+ * The program runs OPENAXIOMsys as a separate process under Windows
+ * using CreateProcess() and asynchronous reader threads. It provides
+ * an interface between OpenAxiom and TeXmacs for windows.
+ *
+ * Before launching, stdin/out/err are each redirected into pipes
+ * so that OPENAXIOM can be fed commands and its output read from
+ * those pipes. A separate thread is created to manage reading the
+ * output of OpenAxiom and sending it (appropriatedly modified) to
+ * TeXmacs. The main thread reads from TeXmacs and sends it's
+ * output to OpenAxiom. In this way the input and output is completely
+ * asynchronous. There may be some advantage to the use of such
+ * "light weight" threads in Windows.
+ *
+ * Build with the command:
+ * gcc tm_openaxiom.c texbreaker.c -o tm_openaxiom.exe
+ * It is known to compile with gcc version 3.4.2 (mingw-special)
+ * under MinGW/MSYS. Other compilers may also work.
+ *
+ * Install the tm_openaxiom.exe file in the directory
+ * C:\Program Files\WinTeXmacs\TeXmacs\bin
+ *
+ * Written by Bill Page 20041203
+ * - based on Maxima test version by Mike Thomas 20030624
+ * (Thankyou Mike!)
+ * and on the TeXmacs tm_openaxiom.c program (linux)
+ * Modified by Bill Page 20041215
+ * - add call to Robert Sutor line-break routine
+ * Modified by Bill Page 20041217
+ * - initialize OPENAXIOM_exe from OPENAXIOM environment variable
+ * Modified by Bill Page 20041220
+ * - use args, TM_OPENAXIOM environment variable and/or
+ * )set output texmacs option,option, ...
+ * to specify options
+ * break no -- disables line-break algorithm
+ * over no -- converts 2-d \over to 1-d /
+ * cdot no -- converts \cdot to \ (space)
+ * space no -- convert \ (space) to \,
+ * big( no -- convert \left( \right to ( )
+ * width 4.5 -- 4.5 inches * 1000
+ * - process OpenAxiom output with no LaTeX content, e.g.
+ * )set output tex off
+ * )set output algebra on
+ * */
+
+#include <windows.h>
+#include <process.h>
+#include <memory.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <io.h>
+
+/* Allow some debugging output from the IO threads */
+/*#define DEBUG_OUT*/
+
+int option_texbreak = 1, /* default options */
+ option_use_over = 1,
+ option_use_cdot = 1,
+ option_big_space = 0,
+ option_big_paren = 1;
+
+#define INP_BUFF_SIZE 3072
+#define OUT_BUFF_SIZE 8192
+char szBuffer[OUT_BUFF_SIZE];
+#define MATHBUFLEN 8*8192
+extern int maxLineWidth;
+extern char bufout[2*MATHBUFLEN];
+
+int nBuffer=0;
+int nRead;
+int IgnorePrompts=0;
+
+#define READ_HANDLE 0
+#define WRITE_HANDLE 1
+
+char OPENAXIOM_cmd[256];
+char ENV_OPENAXIOM[256];
+
+int fdStdOutPipe[2], fdStdInPipe[2], fdStdErrPipe[2];
+
+HANDLE hProcess;
+STARTUPINFO si; /* Only need to set si.cb */
+PROCESS_INFORMATION pi; /* Post launch child process information. */
+
+/* consult the environment */
+
+void parse_options(int nargs, char *args[]) {
+ char *pOPENAXIOM, *pTM_OPENAXIOM, *pOption;
+ int i;
+ float w;
+
+ if (pOPENAXIOM=getenv("OPENAXIOM")) {
+ strcpy(OPENAXIOM_cmd,pOPENAXIOM); strcat(OPENAXIOM_cmd, "/../../../../bin/open-axiom.exe");
+ strcat(OPENAXIOM_cmd," --system=\""); strcat(OPENAXIOM_cmd,pOPENAXIOM);
+ strcat(OPENAXIOM_cmd,"\"");
+ strcpy(ENV_OPENAXIOM,"OPENAXIOM="); strcat(ENV_OPENAXIOM, pOPENAXIOM);
+ }
+ else {
+ printf("You must set the OPENAXIOM environment variable, e.g.\n");
+ exit(1);
+ }
+
+/* e.g. TM_OPENAXIOM='break off, over yes, ...
+ * if not found or different options, ignore silently */
+ for (i=0;i<nargs;i++) {
+ pTM_OPENAXIOM=args[i]; /* args override environment */
+ if (i>0 || (pTM_OPENAXIOM=getenv("TM_OPENAXIOM"))) {
+ if (strstr(pTM_OPENAXIOM,"break off")
+ || strstr(pTM_OPENAXIOM,"break n")
+ || strstr(pTM_OPENAXIOM,"break 0"))
+ option_texbreak=0;
+ if (strstr(pTM_OPENAXIOM,"break on")
+ || strstr(pTM_OPENAXIOM,"break y")
+ || strstr(pTM_OPENAXIOM,"break 1"))
+ option_texbreak=1;
+ if (strstr(pTM_OPENAXIOM,"over off")
+ || strstr(pTM_OPENAXIOM,"over n")
+ || strstr(pTM_OPENAXIOM,"over 0"))
+ option_use_over=0;
+ if (strstr(pTM_OPENAXIOM,"over on")
+ || strstr(pTM_OPENAXIOM,"over y")
+ || strstr(pTM_OPENAXIOM,"over 1"))
+ option_use_over=1;
+ if (strstr(pTM_OPENAXIOM,"cdot off")
+ || strstr(pTM_OPENAXIOM,"cdot n")
+ || strstr(pTM_OPENAXIOM,"cdot 0"))
+ option_use_cdot=0;
+ if (strstr(pTM_OPENAXIOM,"cdot on")
+ || strstr(pTM_OPENAXIOM,"cdot y")
+ || strstr(pTM_OPENAXIOM,"cdot 1"))
+ option_use_cdot=1;
+ if (strstr(pTM_OPENAXIOM,"space off")
+ || strstr(pTM_OPENAXIOM,"space n")
+ || strstr(pTM_OPENAXIOM,"space 0"))
+ option_big_space=0;
+ if (strstr(pTM_OPENAXIOM,"space on")
+ || strstr(pTM_OPENAXIOM,"space y")
+ || strstr(pTM_OPENAXIOM,"space 1"))
+ option_big_space=1;
+ if (strstr(pTM_OPENAXIOM,"big( off")
+ || strstr(pTM_OPENAXIOM,"big( n")
+ || strstr(pTM_OPENAXIOM,"big( 0"))
+ option_big_paren=0;
+ if (strstr(pTM_OPENAXIOM,"big( on")
+ || strstr(pTM_OPENAXIOM,"big( y")
+ || strstr(pTM_OPENAXIOM,"big( 1"))
+ option_big_paren=1;
+ if (pOption=strstr(pTM_OPENAXIOM,"width ")) {
+ sscanf(pOption+strlen("width "),"%f",&w);
+ maxLineWidth=trunc(1000.0*w);
+ };
+ };
+ };
+}
+
+/* This is the OpenAxiom Reader thread. It runs asynchronously and
+ * in parallel with the main thread. It reads output from OpenAxiom
+ * and after some selection and conversion, it is sent on to
+ * TeXmacs. */
+
+unsigned __stdcall StdOutReadThread ( void* pArguments )
+{
+ int nExitCode = STILL_ACTIVE;
+
+ fputs("\2verbatim:",stdout); /* ---> to TeXmacs */
+
+ GetExitCodeProcess ( hProcess, (unsigned long*) &nExitCode );
+
+ while ( nExitCode == STILL_ACTIVE ) {
+ #ifdef DEBUG_OUT
+ fprintf ( stderr, " - Stdout read loop\n" );
+ fflush ( stderr );
+ #endif /* DEBUG_OUT */
+ nRead = _read ( fdStdOutPipe[READ_HANDLE], &szBuffer[nBuffer],
+ OUT_BUFF_SIZE-nBuffer ); /* Read <--- from OpenAxiom */
+
+ szBuffer[nBuffer+nRead]='\0';
+ #ifdef DEBUG_OUT
+ fprintf ( stderr, "After _read on stdoutpipe (%d bytes read)\n%s\n",
+ nRead, &szBuffer[nBuffer] ); fflush ( stderr );
+ #endif /* DEBUG_OUT */
+ while (nRead>0) { /* fill buffer until we see OpenAxiom prompt */
+ if ( strncmp(&szBuffer[nBuffer],"-> ",3)==0 ) { /* done */
+ HandleOutput(szBuffer, nBuffer); /* send output ---> to TeXmacs */
+ nRead = nRead-3; /* keep the left overs */
+ if (nRead>0) strncpy(szBuffer,&szBuffer[nBuffer+3],nRead);
+ nBuffer = 0; szBuffer[nRead]='\0';
+ #ifdef DEBUG_OUT
+ fprintf(stderr, "Leftovers\n%s\n",&szBuffer);
+ fflush(stderr);
+ #endif /* DEBUG_OUT */
+ } else {
+ nBuffer++;
+ nRead--;
+ };
+ };
+ GetExitCodeProcess ( hProcess, (unsigned long*) &nExitCode );
+ };
+
+ fputs("\2latex:\\red The end\\black\5\5",stdout); /* The ends --> TeXmacs */
+ fflush(stdout);
+ _endthreadex(0);
+}
+
+/* This routine parses all OpenAxiom output between -> prompts */
+
+HandleOutput(char Buffer[], int n) /* sends output ---> to TeXmacs */
+{
+ int mmode, i, j;
+
+ #ifdef DEBUG_OUT
+ fprintf(stderr, "HandleOutput IgnorePrompts:%d\n%s\n",IgnorePrompts,
+ Buffer);
+ fflush(stderr);
+ #endif /* DEBUG_OUT */
+ if (IgnorePrompts) --IgnorePrompts; /* counting down */
+ else { /* its a good packet */
+ while (n>0 && Buffer[n-1]=='\n') n--;
+ Buffer[n]='\0'; /* mark the real end */
+ mmode = 0; j=0;
+ while (Buffer[j]=='\n') j++; /* find the real start */
+ for (i=j;i<n;i++) {
+ if (strncmp(&Buffer[i],"$$\n",3)==0) { /* Found a LaTeX marker */
+ #ifdef DEBUG_OUT
+ fprintf(stderr, "LaTeX marker at: %d, mode: %d\n",i,mmode);
+ fflush(stderr);
+ #endif /* DEBUG_OUT */
+ Buffer[i]='\0'; /* something ends here */
+ if (mmode<=0) { /* we were not in mathmode */
+ fputs(&Buffer[j],stdout); /* send the plain text ---> to TeXmacs */
+ mmode = i+3; /* start of LaTeX */
+ fputs("\2latex:$$",stdout);/* tell ---> TeXmacs */
+ } else { /* we were in mathmode */
+ HandleLatex(&Buffer[mmode]); /* make some adjustments */
+ fputs("$$\5",stdout); /* Say "that's all" ---> to TeXmacs */
+ mmode = -1; j=i+3; /* aftermath */
+ }
+ } else { /* this is not a marker */
+ if (mmode<=0) { /* if not in mathmode */
+ if (strncmp(&Buffer[i],"Type:",5)==0) { /* look for OpenAxiom Type */
+ int k;
+ k=i-1; while (Buffer[k]==' ') k--;
+ Buffer[k]='\0'; /* mark end of previous */
+ fputs(&Buffer[j],stdout); /* send the plain text -> to TeXmacs */
+ fprintf(stdout,"\2latex:\\openaxiomtype{%s}\5",
+ &Buffer[i+6]);
+ i=n; j=n; /* and we are done */
+ }
+ }
+ }
+ };
+ if (j<n) {
+ fputs(&Buffer[j],stdout); /* send the plain text ---> to TeXmacs */
+ };
+ /* ask for some more work from ---> TeXmacs */
+ fputs("\2channel:prompt\5\2latex:\\red$\\rightarrow$\\ \5\5",stdout);
+ fflush(stdout); /* Say "give me a prompt" ---> to TeXmacs */
+ fputs("\2verbatim:",stdout); /* maybe plain text next ---> to TeXmacs */
+ }
+}
+
+HandleLatex(char buf[]) { /* fixup Latex coding */
+
+ char *ptr1, *ptr2, *ptr3;
+ char label[64];
+
+/* /n -> blank */
+ while (ptr1=strchr(buf,'\n')) { *ptr1=' '; };
+
+if (option_texbreak) { /* break long TeX lines */
+
+/* prepare OpenAxiom output in buf for call to texbreak */
+
+/* remove the label and save it for later */
+ label[0]='\0';
+ while (ptr1=strstr(buf,"\\leqno(")) {
+ if ((ptr2=strchr(ptr1,')')) && (ptr2-ptr1<64)) {
+ ptr2++;
+ strncpy(label,ptr1,ptr2-ptr1); label[ptr2-ptr1]='\0';
+ strcpy(ptr1,ptr2);
+ }
+ };
+
+ texbreak(buf); /* output is in global external called bufout */
+ strcat(bufout,"\\hfill \\leqno ");
+ strcat(bufout,&label[6]); /* put label back */
+} else {
+ strcpy(bufout,buf);
+};
+
+/* do some LaTex conversions for TeXmacs */
+
+/* \root { a } \of { b } ---> \sqrt[ a ] { b } */
+/* ptr1^ ptr2^ ^ptr3 ^ ^ ptr1^ ^ */
+
+ while (ptr1=strstr(bufout,"\\root")) {
+ ptr2=ptr1+5; while (*ptr2==' ') ptr2++;
+ if ((*ptr2=='{') && (ptr3=strstr(ptr2,"}"))) {
+ #ifdef DEBUG_OUT
+ fprintf(stderr, "ptr1: %s\nptr2: %s\nptr3: %s\n",ptr1,ptr2,ptr3);
+ fflush(stderr);
+ #endif /* DEBUG_OUT */
+ strncpy(ptr1,"\\sqrt[",6); ptr1=ptr1+6;
+ strncpy(ptr1,ptr2+1,ptr3-ptr2-1); ptr1=ptr1+(ptr3-ptr2-1);
+ strncpy(ptr1,"]",1); ptr1++;
+ ptr3++; while (*ptr3==' ') ptr3++;
+ #ifdef DEBUG_OUT
+ fprintf(stderr, "ptr1: %s\nptr2: %s\nptr3: %s\n",ptr1,ptr2,ptr3);
+ fflush(stderr);
+ #endif /* DEBUG_OUT */
+ if (strncmp(ptr3,"\\of",3)==0) {
+ ptr3+=3; while (*ptr3==' ') ptr3++;
+ if (*ptr3=='{') {
+ strcpy(ptr1,ptr3);
+ } else {
+ error("No \\of { \n");
+ }
+ } else {
+ error("No \\of \n");
+ }
+ } else {
+ error("No \\root { } \n");
+ }
+ };
+
+ if (!option_big_space) { /* use smaller spaces \ ---> \, */
+ while (ptr1=strstr(bufout,"\\ ")) {
+ strncpy(ptr1,"\\,",2); /* use thin spaces */
+ };
+ };
+
+/* other possible conversions */
+
+ if (!option_use_cdot) {
+ while (ptr1=strstr(bufout,"\\cdot")) {
+ strncpy(ptr1,"\\ ",2);
+ strcpy(ptr1+2,ptr1+5);
+ };
+ };
+
+ if (!option_big_paren) {
+ while (ptr1=strstr(bufout,"\\left(")) {
+ strncpy(ptr1,"(",1);
+ strcpy(ptr1+1,ptr1+6);
+ };
+ while (ptr1=strstr(bufout,"\\right)")) {
+ strncpy(ptr1,")",1);
+ strcpy(ptr1+1,ptr1+7);
+ };
+ };
+ if (!option_use_over) {
+ while (ptr1=strstr(bufout,"\\over")) {
+ strncpy(ptr1,"/",1);
+ strcpy(ptr1+1,ptr1+5);
+ };
+ };
+ #ifdef DEBUG_OUT
+ fprintf(stderr, "HandleLatex:\n%s\n",bufout);
+ fflush(stderr);
+ #endif /* DEBUG_OUT */
+ fputs(bufout,stdout); /* send the LaTeX code ---> to TeXmacs */
+}
+
+unsigned __stdcall StdErrReadThread ( void* pArguments )
+{
+ int nExitCode = STILL_ACTIVE;
+ int nRead;
+ char szBuffer[OUT_BUFF_SIZE];
+
+ GetExitCodeProcess ( hProcess, (unsigned long*) &nExitCode );
+
+ while ( nExitCode == STILL_ACTIVE ) {
+ #ifdef DEBUG_OUT
+ fprintf ( stderr, " - Stderr read loop\n" ); fflush ( stderr );
+ #endif /* DEBUG_OUT */
+ nRead = _read ( fdStdErrPipe[READ_HANDLE], szBuffer, OUT_BUFF_SIZE );
+ #ifdef DEBUG_OUT
+ fprintf ( stderr, "After _read on stderrpipe (%d bytes read)\n",
+ nRead );
+ fflush ( stderr );
+ #endif /* DEBUG_OUT */
+ if ( nRead ) { /* just pass the message on through to TeXmacs */
+ fwrite(szBuffer, 1, nRead, stderr);
+ }
+ GetExitCodeProcess ( hProcess, (unsigned long*) &nExitCode );
+ }
+ _endthreadex(0);
+}
+
+void pipe_write(int fdPipe, char Buffer[])
+{
+ _write(fdPipe, Buffer, strlen(Buffer) );
+}
+
+/* process texmacs options */
+
+process_options(char line[]) {
+ char *optargs[2];
+
+ optargs[1]=line;
+ if (*(optargs[1])!='\n') {
+ parse_options(2,optargs);
+ } else { /* display current options */
+ show_options();
+ };
+ /* ask for some more work from ---> TeXmacs */
+ fputs("\2channel:prompt\5\2latex:\\red$\\rightarrow$\\ \5\5",stdout);
+ fflush(stdout); /* Say "give me a prompt" ---> to TeXmacs */
+ fputs("\2verbatim:",stdout); /* maybe plain text next ---> to TeXmacs */
+
+ #ifdef DEBUG_OUT
+ fprintf ( stderr,
+ "TM_OPENAXIOM=texbreak:%d,use_over:%d,use_cdot:%d,big_space:%d,big_paren:%d,\n",
+ option_texbreak, option_use_over, option_use_cdot,
+ option_big_space, option_big_paren );
+ fprintf ( stderr,
+ " maxLineWidth:%d\n", maxLineWidth );
+ fflush ( stderr );
+ #endif /* DEBUG_OUT */
+}
+
+show_options() {
+ fprintf(stdout,
+"--------------------------- The texmacs Option ----------------------------\n\
+\n\
+ Description: options for display of OPENAXIOM output in TeXmacs\n\
+\n\
+ )set output texmacs is used to control the TeXmacs-OPENAXIOM interface\n\
+The default values are controlled by environment variable TM_OPENAXIOM\n\
+and may be overriden by command line options.\n\
+\n\
+Syntax: )set output texmacs <arg>\n\
+ where arg can be one or more of\n\
+ break <on>|<off> line-break algorithm\n\
+ over <on>|<off> convert 2-d \\over to 1-d /\n\
+ cdot <on>|<off> convert \\cdot to \\ (space)\n\
+ space <on>|<off> convert \\ (space) to \\,\n\
+ big( <on>|<off> convert \\left( \\right to ( )\n\
+ width <9.99> line width in inches\n\
+\n\
+ <on> may be on, yes, 1\n\
+ <off> may be off, no , 0\n\
+\n\
+The current settings are:\n\
+ break %d, over %d, cdot %d, space %d, big( %d, width %2.3f\n",
+ option_texbreak, option_use_over, option_use_cdot,
+ option_big_space, option_big_paren, maxLineWidth/1000.0 );
+
+};
+
+int main(int nargs, char *args[])
+{
+ HANDLE hStdOutReadThread;
+ int fdStdOut, fdStdIn;
+ unsigned threadIDOut;
+ HANDLE hStdErrReadThread;
+ int fdStdErr;
+ unsigned threadIDErr;
+ int i;
+ char line[INP_BUFF_SIZE];
+
+ parse_options(nargs,args);
+
+ #ifdef DEBUG_OUT
+ fprintf ( stderr, "CREATE PROCESS: %s\n", OPENAXIOM_cmd );
+ fprintf ( stderr, "Setting env var: %s\n", ENV_OPENAXIOM );
+ fprintf ( stderr,
+ "TM_OPENAXIOM=texbreak:%d,use_over:%d,use_cdot:%d,big_space:%d,big_paren:%d,\n",
+ option_texbreak, option_use_over, option_use_cdot,
+ option_big_space, option_big_paren );
+ fprintf ( stderr,
+ " maxLineWidth:%d\n", maxLineWidth );
+ fflush ( stderr );
+ #endif /* DEBUG_OUT */
+
+ if ( -1 == _setmode( _fileno( stdin ), _O_BINARY ) ) {
+ perror ( "machinfo: Cannot set stdin BINARY mode" ); exit(1);
+ };
+ if ( -1 == _setmode( _fileno( stdout ), _O_BINARY ) ) {
+ perror ( "machinfo: Cannot set stdout BINARY mode" ); exit(1);
+ };
+ if ( -1 == _setmode( _fileno( stderr ), _O_BINARY ) ) {
+ perror ( "machinfo: Cannot set stderr BINARY mode" ); exit(1);
+ };
+
+ /* Make pipes to be passed to the spawned process as stdin/out/err */
+ if ( _pipe ( fdStdOutPipe, 512, O_BINARY | O_NOINHERIT ) == -1 ) return 1;
+ if ( _pipe ( fdStdInPipe, 512, O_BINARY | O_NOINHERIT ) == -1 ) return 1;
+ if ( _pipe ( fdStdErrPipe, 512, O_BINARY | O_NOINHERIT ) == -1 ) return 1;
+
+ /* Duplicate and save original stdin/out/err handles */
+ fdStdOut = _dup ( _fileno(stdout) );
+ fdStdIn = _dup ( _fileno(stdin) );
+ fdStdErr = _dup ( _fileno(stderr) );
+
+ /* Duplicate write end of new pipes to current stdout/err handles,
+ * read to stdin */
+ if ( _dup2 ( fdStdOutPipe[WRITE_HANDLE], _fileno(stdout) ) != 0 ) return 2;
+ if ( _dup2 ( fdStdInPipe[READ_HANDLE], _fileno(stdin) ) != 0 ) return 2;
+ if ( _dup2 ( fdStdErrPipe[WRITE_HANDLE], _fileno(stderr) ) != 0 ) return 2;
+ /* Close the duplicated handles to the new pipes */
+ close ( fdStdOutPipe[WRITE_HANDLE] );
+ close ( fdStdInPipe[READ_HANDLE] );
+ close ( fdStdErrPipe[WRITE_HANDLE] );
+
+ putenv ( ENV_OPENAXIOM );
+
+ /* Zero startup and process info structures, take care of Windows
+ * startup info structure future proofing. */
+ ZeroMemory( &si, sizeof(si) );
+ si.cb = sizeof(si);
+ ZeroMemory( &pi, sizeof(pi) );
+
+ /* Start the child process. */
+ if ( !CreateProcess(
+ NULL, /* No module name (use command line). */
+ OPENAXIOM_cmd, /* Command line. */
+ NULL, /* Process handle not inheritable. */
+ NULL, /* Thread handle not inheritable. */
+ TRUE, /* Allow handle inheritance. */
+ 0, /* No creation flags. */
+ NULL, /* Use parent's environment block. */
+ NULL, /* Use parent's starting directory. */
+ &si, /* Pointer to STARTUPINFO structure.*/
+ &pi ) /* Pointer to PROCESS_INFORMATION structure. */ ) {
+ fprintf(stderr, "CreateProcess failed: %s\n", args[1]);
+ fflush(stderr);
+ return -1;
+ }
+ hProcess = pi.hProcess;
+
+ /* Now that the process is launched,
+ * replace the original stdin/out/err handles */
+ if ( _dup2 ( fdStdOut, _fileno ( stdout ) ) != 0 ) return 3;
+ if ( _dup2 ( fdStdIn, _fileno ( stdin ) ) != 0 ) return 3;
+ if ( _dup2 ( fdStdErr, _fileno ( stderr ) ) != 0 ) return 3;
+
+ /* Close duplicates */
+ close(fdStdOut);
+ close(fdStdIn);
+ close(fdStdErr);
+
+ /* The child process will become the OpenAxiom read filter and
+ * we will be the OpenAxiom write filter. */
+
+ /* Create the OpenAxiom stderr listening thread. (Doesn't do much.) */
+ hStdErrReadThread = (HANDLE)_beginthreadex( NULL, 0, &StdErrReadThread,
+ NULL, 0, &threadIDErr );
+ if ( 0 == hStdErrReadThread ) return 5;
+
+ /* * * * * * * * * */
+ /* start talking! */
+ /* * * * * * * * * */
+
+ IgnorePrompts = 5; /* Tell the OpenAxiom Reader to ignore first 5 prompts */
+ /* then create the OpenAxiom stdout Reader thread.*/
+ hStdOutReadThread = (HANDLE)_beginthreadex( NULL, 0, &StdOutReadThread,
+ NULL, 0, &threadIDOut );
+ if ( 0 == hStdOutReadThread ) return 5;
+ /* start force-feeding ---> to OpenAxiom */
+ pipe_write(fdStdInPipe[WRITE_HANDLE],")set message prompt plain\n" ); /* 1 */
+ pipe_write(fdStdInPipe[WRITE_HANDLE],")set messages autoload off\n" );/* 2 */
+ pipe_write(fdStdInPipe[WRITE_HANDLE],")set quit unprotected\n" ); /* 3 */
+ pipe_write(fdStdInPipe[WRITE_HANDLE],")set output tex on\n" ); /* 4 */
+ pipe_write(fdStdInPipe[WRITE_HANDLE],")set output algebra off\n" ); /* 5 */
+ while (fgets(line,INP_BUFF_SIZE,stdin)!=NULL) { /* wait <--- for TeXmacs */
+ #ifdef DEBUG_OUT
+ fprintf ( stderr, "Input:\n%s", line );
+ #endif /* DEBUG_OUT */
+ if (strncmp(line,")set output texmacs",
+ strlen(")set output texmacs"))==0) { /* process texmacs options */
+ process_options(&line[strlen(")set output texmacs")]);
+ } else {
+ pipe_write(fdStdInPipe[WRITE_HANDLE], line ); /* Start ---> OpenAxiom */
+ }
+ };
+ if (nBuffer) HandleOutput(szBuffer,nBuffer); /* anything leftover? */
+ pipe_write(fdStdInPipe[WRITE_HANDLE], ")quit\n" ); /* stop work */
+
+ WaitForSingleObject ( hStdErrReadThread, INFINITE );
+ WaitForSingleObject ( hStdOutReadThread, INFINITE );
+
+ /* Wait until child process exits to block the terminal. */
+ WaitForSingleObject( pi.hProcess, INFINITE );
+
+ /* As we are using gebinthreadex/endthreadex,
+ * we must close the thread handles. */
+ CloseHandle ( hStdOutReadThread );
+ CloseHandle ( hStdErrReadThread );
+
+ return 0;
+}
|