Return to batch.c.fork CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Annotation of OpenXM_contrib2/asir2000/builtin/batch.c.fork, Revision 1.1

1.1     ! noro        1: #if !defined(VISUAL)
        !             2:
        !             3: #include <stdio.h>
        !             4: #include <stdlib.h>
        !             5:
        !             6: int exec_file(char *bindir,char *fname) {
        !             7:        char command[BUFSIZ];
        !             8:        int pid,status;
        !             9:
        !            10:        sprintf(command,"%s/asir",bindir);
        !            11:        pid = fork();
        !            12:        if ( pid ) {
        !            13:                wait(&status);
        !            14:        } else {
        !            15:                setpgid(0,getpid());
        !            16:                execlp(command,"asir","-f",fname,0);
        !            17:        }
        !            18: }
        !            19:
        !            20: #else
        !            21:
        !            22: #include <windows.h>
        !            23: #include <stdlib.h>
        !            24: #include <stdio.h>
        !            25: #include <io.h>
        !            26: #include <fcntl.h>
        !            27: #include <process.h>
        !            28:
        !            29: static void read_until_eof();
        !            30:
        !            31: static HANDLE hRead,hWrite,hNotify,hNotify_Ack,hIntr,hIntr_Ack,hKill,hProc;
        !            32:
        !            33: int exec_file(char *bindir,char *fname) {
        !            34:        int i;
        !            35:        char *av[BUFSIZ];
        !            36:        char AsirExe[BUFSIZ];
        !            37:        DWORD tid,mypid,pid,len;
        !            38:        HANDLE hR0,hW0,hR1,hW1;
        !            39:     SECURITY_ATTRIBUTES SecurityAttributes;
        !            40:        char remread[10],remwrite[10];
        !            41:        char notify[100],notify_ack[100],intr[100],intr_ack[100],kill[100];
        !            42:
        !            43:        mypid = GetCurrentProcessId();
        !            44:        sprintf(notify,"asir_notify_%d",mypid);
        !            45:        sprintf(notify_ack,"asir_ack_%d",mypid);
        !            46:        sprintf(intr,"asir_intr_%d",mypid);
        !            47:        sprintf(intr_ack,"asir_intr_ack_%d",mypid);
        !            48:        sprintf(kill,"asir_kill_%d",mypid);
        !            49:        hNotify = CreateEvent(NULL,TRUE,FALSE,notify);
        !            50:        hNotify_Ack = CreateEvent(NULL,TRUE,FALSE,notify_ack);
        !            51:        hIntr = CreateEvent(NULL,TRUE,FALSE,intr);
        !            52:        hIntr_Ack = CreateEvent(NULL,TRUE,FALSE,intr_ack);
        !            53:        hKill = CreateEvent(NULL,TRUE,FALSE,kill);
        !            54:
        !            55:     SecurityAttributes.nLength = sizeof(SecurityAttributes);
        !            56:     SecurityAttributes.lpSecurityDescriptor = NULL;
        !            57:     SecurityAttributes.bInheritHandle = TRUE;
        !            58:     CreatePipe(&hR0, &hW0, &SecurityAttributes, 65536);
        !            59:     CreatePipe(&hR1, &hW1, &SecurityAttributes, 65536);
        !            60:
        !            61:        hRead = hR0;
        !            62:        hWrite = hW1;
        !            63:        sprintf(remread,"%d",(DWORD)hR1);
        !            64:        sprintf(remwrite,"%d",(DWORD)hW0);
        !            65:
        !            66:        sprintf(AsirExe,"%s\\engine32.exe",bindir);
        !            67:        _setargv();
        !            68:        av[0] = "asir";
        !            69:        av[1] = remread;
        !            70:        av[2] = remwrite;
        !            71:        av[3] = notify;
        !            72:        av[4] = notify_ack;
        !            73:        av[5] = intr;
        !            74:        av[6] = intr_ack;
        !            75:        av[7] = kill;
        !            76:        av[8] = "-norc";
        !            77:        av[9] = "-f";
        !            78:        av[10] = fname;
        !            79:        av[11] = NULL;
        !            80:        hProc = (HANDLE)_spawnv(_P_NOWAIT,AsirExe,av);
        !            81:        if ( hProc == (HANDLE)-1 ) {
        !            82:                fprintf(stderr,"%s がありません",AsirExe);
        !            83:                return 0;
        !            84:        }
        !            85:        read_until_eof();
        !            86:        return 1;
        !            87: }
        !            88:
        !            89: int doing_batch = 0;
        !            90: static char insert_buf[BUFSIZ*10];
        !            91: static int insert_buf_len = 0;
        !            92:
        !            93: static void read_until_eof()
        !            94: {
        !            95:        char *p;
        !            96:        DWORD len;
        !            97:        unsigned int cmdsize,cmd,size;
        !            98:
        !            99:        doing_batch = 1;
        !           100:        while ( 1 ) {
        !           101:                WaitForSingleObject(hNotify,(DWORD)-1);
        !           102:                ResetEvent(hNotify);
        !           103:                SetEvent(hNotify_Ack);
        !           104:                ReadFile(hRead,&cmdsize,sizeof(unsigned int),&len,NULL);
        !           105:                cmd = cmdsize>>16;
        !           106:                size = cmdsize&0xffff;
        !           107:                if ( !cmd ) {
        !           108:                        doing_batch = 0;
        !           109:                        return;
        !           110:                } else if ( size )
        !           111:                        ReadFile(hRead,insert_buf,size,&len,NULL);
        !           112:        }
        !           113: }
        !           114:
        !           115: void send_intr() {
        !           116:        PulseEvent(hIntr);
        !           117: }
        !           118:
        !           119: void terminate_batch() {
        !           120:        TerminateProcess(hProc,0);
        !           121: }
        !           122: #endif /* VISUAL */