Return to tm_asir.c CVS log

Up to [local] / OpenXM / src / texmacs / asir / src

Annotation of OpenXM/src/texmacs/asir/src/tm_asir.c, Revision 1.1

1.1     ! ohara       1: /* -*- mode: C -*- */
        !             2: /* $OpenXM$ */
        !             3:
        !             4: #include <stdio.h>
        !             5: #include <stdlib.h>
        !             6: #include <string.h>
        !             7: #include <unistd.h>
        !             8: #include <fcntl.h>
        !             9: #include <sys/types.h>
        !            10: #include <sys/socket.h>
        !            11:
        !            12: #if defined(__sun__)
        !            13: #include <arpa/inet.h>
        !            14: #endif
        !            15:
        !            16: #define DATA_BEGIN   2
        !            17: #define DATA_END     5
        !            18: #define DATA_ESCAPE  27
        !            19:
        !            20: #define OX_COMMAND 513
        !            21: #define OX_DATA    514
        !            22: #define CMO_INT32  2
        !            23: #define CMO_STRING 4
        !            24: #define SM_popString                  263
        !            25: #define SM_executeStringByLocalParser 268
        !            26: #define SM_executeFunction            269
        !            27:
        !            28: #define SIZE_BUFFER 2048
        !            29:
        !            30: #define WRITE(ptr,size)  fwrite((ptr),1,(size),ox_fp)
        !            31: #define READ(ptr,size)   fread((ptr),1,(size),ox_fp)
        !            32: #define FLUSH()          fflush(ox_fp)
        !            33: #define PIPE(fd)         socketpair(AF_UNIX,SOCK_STREAM,0,(fd))
        !            34:
        !            35: int dat_string[3]      = {OX_DATA,    0, CMO_STRING};
        !            36: int dat_int32[3]       = {OX_DATA,    0, CMO_INT32};
        !            37: int cmd_exeFunction[3] = {OX_COMMAND, 0, SM_executeFunction};
        !            38: int cmd_exeString[3]   = {OX_COMMAND, 0, SM_executeStringByLocalParser};
        !            39: int cmd_popString[3]   = {OX_COMMAND, 0, SM_popString};
        !            40:
        !            41: FILE *ox_fp;
        !            42:
        !            43: void load_asir()
        !            44: {
        !            45:     int pid;
        !            46:     int fd[2];
        !            47:     int offer;
        !            48:     if (PIPE(fd) == 0) {
        !            49:         if ((pid = fork()) > 0) {
        !            50:             close(fd[0]);
        !            51:             ox_fp = fdopen(fd[1], "w+");
        !            52:             /* deteriming byte order */
        !            53:             READ(&offer, 1);
        !            54:             offer=1;
        !            55:             WRITE(&offer, 1); FLUSH();
        !            56:             return;
        !            57:         }else if (pid == 0) {
        !            58:             close(fd[1]);
        !            59:             dup2(fd[0], 3);
        !            60:             dup2(3, 4);
        !            61:             dup2(open("/dev/null", O_APPEND|O_RDWR, 0644), 2); /* stderr */
        !            62:             execlp("ox_asir", "ox_asir", "-quiet", NULL);
        !            63:         }
        !            64:     }
        !            65:     perror("load_asir() :");
        !            66:     exit(1);
        !            67: }
        !            68:
        !            69: void send_int(int n)
        !            70: {
        !            71:     WRITE(dat_int32, sizeof(int)*3);
        !            72:     WRITE(&n, sizeof(int));
        !            73: }
        !            74:
        !            75: void send_string(char *s)
        !            76: {
        !            77:     int len = strlen(s);
        !            78:     WRITE(dat_string, sizeof(int)*3);
        !            79:     WRITE(&len, sizeof(int));
        !            80:     WRITE(s, len);
        !            81: }
        !            82:
        !            83: void send_cmd(int *cmd)
        !            84: {
        !            85:     WRITE(cmd, sizeof(int)*3);
        !            86: }
        !            87:
        !            88: char *recv_string()
        !            89: {
        !            90:     static char *s;
        !            91:     int len;
        !            92:     int null[3];
        !            93:     READ(null, sizeof(int)*3);
        !            94:     READ(&len, sizeof(int));
        !            95:     if ((s = realloc(s, len+1)) != NULL) {
        !            96:         s[len] = 0;
        !            97:         READ(s, len);
        !            98:         return s;
        !            99:     }
        !           100:     perror("recv_string(): ");
        !           101:     exit(1);
        !           102: }
        !           103:
        !           104: char *asir(char *cmd)
        !           105: {
        !           106:     send_string(cmd);
        !           107:     send_cmd(cmd_exeString);
        !           108:     send_int(1);
        !           109:     send_string("print_tex_form");
        !           110:     send_cmd(cmd_exeFunction);
        !           111:     send_cmd(cmd_popString);
        !           112:     return recv_string();
        !           113: }
        !           114:
        !           115: char *asir_copyright()
        !           116: {
        !           117:     send_string("copyright();");
        !           118:     send_cmd(cmd_exeString);
        !           119:     send_cmd(cmd_popString);
        !           120:     return recv_string();
        !           121: }
        !           122:
        !           123: void output_escape(char *s)
        !           124: {
        !           125:     while (*s != '\0') {
        !           126:         if (*s == DATA_BEGIN || *s == DATA_END || *s == DATA_ESCAPE) {
        !           127:             fputc(DATA_ESCAPE, stdout);
        !           128:         }
        !           129:         fputc(*s, stdout);
        !           130:         s++;
        !           131:     }
        !           132: }
        !           133:
        !           134: void output_latex(char *s)
        !           135: {
        !           136:     fputs("\2latex:$", stdout);
        !           137:     output_escape(s);
        !           138:     fputs("$\5", stdout);
        !           139:     fflush(stdout);
        !           140: }
        !           141:
        !           142: void output_verbatim(char *s)
        !           143: {
        !           144:     fputs("\2verbatim:", stdout);
        !           145:     output_escape(s);
        !           146:     fputs("\5", stdout);
        !           147:     fflush(stdout);
        !           148: }
        !           149:
        !           150: int main()
        !           151: {
        !           152:     char buffer[SIZE_BUFFER];
        !           153:     load_asir();
        !           154:     output_verbatim(asir_copyright());
        !           155:     while(fgets(buffer, SIZE_BUFFER, stdin) != NULL) {
        !           156:         output_latex(asir(buffer));
        !           157:     }
        !           158:     return 0;
        !           159: }