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.2

1.1       ohara       1: /* -*- mode: C -*- */
1.2     ! ohara       2: /* $OpenXM: OpenXM/src/texmacs/asir/src/tm_asir.c,v 1.1 2004/02/25 14:45:28 ohara Exp $ */
        !             3:
        !             4: /*
        !             5: usage: tm_asir
        !             6:        tm_asir -d [logfile]
        !             7: */
1.1       ohara       8:
                      9: #include <stdio.h>
                     10: #include <stdlib.h>
                     11: #include <string.h>
                     12: #include <unistd.h>
                     13: #include <fcntl.h>
                     14: #include <sys/types.h>
                     15: #include <sys/socket.h>
                     16:
                     17: #if defined(__sun__)
                     18: #include <arpa/inet.h>
                     19: #endif
                     20:
                     21: #define DATA_BEGIN   2
                     22: #define DATA_END     5
                     23: #define DATA_ESCAPE  27
                     24:
                     25: #define OX_COMMAND 513
                     26: #define OX_DATA    514
                     27: #define CMO_INT32  2
                     28: #define CMO_STRING 4
                     29: #define SM_popString                  263
                     30: #define SM_executeStringByLocalParser 268
                     31: #define SM_executeFunction            269
                     32:
                     33: #define SIZE_BUFFER 2048
1.2     ! ohara      34: #define DEFAULT_LOG_FILE "/tmp/tm_asir.log"
1.1       ohara      35:
                     36: #define WRITE(ptr,size)  fwrite((ptr),1,(size),ox_fp)
                     37: #define READ(ptr,size)   fread((ptr),1,(size),ox_fp)
                     38: #define FLUSH()          fflush(ox_fp)
                     39: #define PIPE(fd)         socketpair(AF_UNIX,SOCK_STREAM,0,(fd))
                     40:
                     41: int dat_string[3]      = {OX_DATA,    0, CMO_STRING};
                     42: int dat_int32[3]       = {OX_DATA,    0, CMO_INT32};
                     43: int cmd_exeFunction[3] = {OX_COMMAND, 0, SM_executeFunction};
                     44: int cmd_exeString[3]   = {OX_COMMAND, 0, SM_executeStringByLocalParser};
                     45: int cmd_popString[3]   = {OX_COMMAND, 0, SM_popString};
                     46:
                     47: FILE *ox_fp;
1.2     ! ohara      48: FILE *logfp;
        !            49: static int counter;
        !            50:
        !            51: char *chomp(char *s)
        !            52: {
        !            53:     char *t = s+strlen(s)-1;
        !            54:     *t = (*t != '\n')? *t: 0;
        !            55:     return s;
        !            56: }
        !            57:
        !            58: void put_log(char *format, char *mesg)
        !            59: {
        !            60:     fprintf(logfp, "[%d]", counter++);
        !            61:     fprintf(logfp, format);
        !            62:     fprintf(logfp, ":%s\n", mesg);
        !            63:     fflush(logfp);
        !            64: }
        !            65:
        !            66: void open_log(char *logfile)
        !            67: {
        !            68:     logfp = fopen(logfile, "a");
        !            69: }
1.1       ohara      70:
                     71: void load_asir()
                     72: {
                     73:     int pid;
                     74:     int fd[2];
                     75:     int offer;
                     76:     if (PIPE(fd) == 0) {
                     77:         if ((pid = fork()) > 0) {
                     78:             close(fd[0]);
                     79:             ox_fp = fdopen(fd[1], "w+");
                     80:             /* deteriming byte order */
                     81:             READ(&offer, 1);
                     82:             offer=1;
                     83:             WRITE(&offer, 1); FLUSH();
                     84:             return;
                     85:         }else if (pid == 0) {
                     86:             close(fd[1]);
                     87:             dup2(fd[0], 3);
                     88:             dup2(3, 4);
                     89:             dup2(open("/dev/null", O_APPEND|O_RDWR, 0644), 2); /* stderr */
                     90:             execlp("ox_asir", "ox_asir", "-quiet", NULL);
                     91:         }
                     92:     }
                     93:     perror("load_asir() :");
                     94:     exit(1);
                     95: }
                     96:
                     97: void send_int(int n)
                     98: {
                     99:     WRITE(dat_int32, sizeof(int)*3);
                    100:     WRITE(&n, sizeof(int));
                    101: }
                    102:
                    103: void send_string(char *s)
                    104: {
                    105:     int len = strlen(s);
                    106:     WRITE(dat_string, sizeof(int)*3);
                    107:     WRITE(&len, sizeof(int));
                    108:     WRITE(s, len);
                    109: }
                    110:
                    111: void send_cmd(int *cmd)
                    112: {
                    113:     WRITE(cmd, sizeof(int)*3);
                    114: }
                    115:
                    116: char *recv_string()
                    117: {
                    118:     static char *s;
                    119:     int len;
                    120:     int null[3];
                    121:     READ(null, sizeof(int)*3);
                    122:     READ(&len, sizeof(int));
                    123:     if ((s = realloc(s, len+1)) != NULL) {
                    124:         s[len] = 0;
                    125:         READ(s, len);
                    126:         return s;
                    127:     }
                    128:     perror("recv_string(): ");
                    129:     exit(1);
                    130: }
                    131:
                    132: char *asir(char *cmd)
                    133: {
                    134:     send_string(cmd);
                    135:     send_cmd(cmd_exeString);
                    136:     send_int(1);
                    137:     send_string("print_tex_form");
                    138:     send_cmd(cmd_exeFunction);
                    139:     send_cmd(cmd_popString);
                    140:     return recv_string();
                    141: }
                    142:
                    143: char *asir_copyright()
                    144: {
                    145:     send_string("copyright();");
                    146:     send_cmd(cmd_exeString);
                    147:     send_cmd(cmd_popString);
                    148:     return recv_string();
                    149: }
                    150:
                    151: void output_escape(char *s)
                    152: {
                    153:     while (*s != '\0') {
                    154:         if (*s == DATA_BEGIN || *s == DATA_END || *s == DATA_ESCAPE) {
                    155:             fputc(DATA_ESCAPE, stdout);
                    156:         }
                    157:         fputc(*s, stdout);
                    158:         s++;
                    159:     }
                    160: }
                    161:
                    162: void output_latex(char *s)
                    163: {
                    164:     fputs("\2latex:$", stdout);
                    165:     output_escape(s);
                    166:     fputs("$\5", stdout);
                    167:     fflush(stdout);
                    168: }
                    169:
                    170: void output_verbatim(char *s)
                    171: {
                    172:     fputs("\2verbatim:", stdout);
                    173:     output_escape(s);
                    174:     fputs("\5", stdout);
                    175:     fflush(stdout);
                    176: }
                    177:
1.2     ! ohara     178: int main(int argc, char *argv[])
1.1       ohara     179: {
                    180:     char buffer[SIZE_BUFFER];
1.2     ! ohara     181:     int debug = 0;
        !           182:     char *logfile = DEFAULT_LOG_FILE;
        !           183:     if (argc > 1 && strcmp(argv[1], "-d") == 0) {
        !           184:         debug = 1;
        !           185:         if (argc > 2) {
        !           186:             logfile = argv[2];
        !           187:         }
        !           188:     }
        !           189:     if (!debug) {
        !           190:         load_asir();
        !           191:         output_verbatim(asir_copyright());
        !           192:     }else {
        !           193:         open_log(logfile);
        !           194:         sprintf(buffer, "This is Plugin Debuger with logging to %s.", logfile);
        !           195:         output_verbatim(buffer);
        !           196:                put_log("verbatim", buffer);
        !           197:     }
1.1       ohara     198:     while(fgets(buffer, SIZE_BUFFER, stdin) != NULL) {
1.2     ! ohara     199:         if (!debug) {
        !           200:             output_latex(asir(buffer));
        !           201:         }else {
        !           202:             output_verbatim(chomp(buffer));
        !           203:                        put_log("verbatim", buffer);
        !           204:         }
1.1       ohara     205:     }
                    206:     return 0;
                    207: }