The Ecere SDK - sdk/blob - ecere/src/sys/DualPipe.ec

   1 #include <stdarg.h>
   2
   3 namespace sys;
   4
   5 import "System"
   6
   7 default:
   8
   9 typedef struct _DualPipe _DualPipe;
  10
  11 // IMPLEMENTATION OF THESE IS IN _DualPipe.c
  12 void DualPipe_Destructor(_DualPipe * dp);
  13 void DualPipe_CloseInput(_DualPipe * dp);
  14 void DualPipe_CloseOutput(_DualPipe * dp);
  15 int DualPipe_Read(_DualPipe * dp, byte * buffer, uint size, uint count);
  16 int DualPipe_Write(_DualPipe * dp, const byte * buffer, uint size, uint count);
  17 bool DualPipe_Getc(_DualPipe * dp, char * ch);
  18 bool DualPipe_Putc(_DualPipe * dp, char ch);
  19 bool DualPipe_Puts(_DualPipe * dp, const char * string);
  20 bool DualPipe_Seek(_DualPipe * dp, int pos, FileSeekMode mode);
  21 uint DualPipe_Tell(_DualPipe * dp);
  22 bool DualPipe_Eof(_DualPipe * dp);
  23 bool DualPipe_GetSize(_DualPipe * dp);
  24 bool DualPipe_Peek(_DualPipe * dp);
  25 void DualPipe_Terminate(_DualPipe * dp);
  26 int DualPipe_GetExitCode(_DualPipe * dp);
  27 int DualPipe_GetProcessID(_DualPipe * dp);
  28 void DualPipe_Wait(_DualPipe * dp);
  29 _DualPipe * _DualPipeOpen(PipeOpenMode mode, const char * commandLine, const char * env, void ** inputPtr, void ** outputPtr);
  30
  31 private:
  32
  33 public class PipeOpenMode { public bool output:1, error:1, input:1, showWindow:1; };
  34
  35 public class DualPipe : File
  36 {
  37    void * dp;
  38
  39    ~DualPipe() { DualPipe_Destructor(dp); }
  40    void CloseInput() { (input != null) ? File::CloseInput() : DualPipe_CloseInput(dp); }
  41    void CloseOutput() { (output != null) ? File::CloseOutput() : DualPipe_CloseOutput(dp); }
  42    int Read(byte * buffer, uint size, uint count) { return DualPipe_Read(dp, buffer, size, count); }
  43    int Write(const byte * buffer, uint size, uint count) { return output ? File::Write(buffer, size, count) : DualPipe_Write(dp, buffer, size, count); }
  44    bool Getc(char * ch) { return input ? File::Getc(ch) : DualPipe_Getc(dp, ch); }
  45    bool Putc(char ch) { return output ? File::Putc(ch) : DualPipe_Putc(dp, ch); }
  46    bool Puts(const char * string) { return output ? (File::Puts(string), File::Flush()) : DualPipe_Puts(dp, string); }
  47    bool Seek(int pos, FileSeekMode mode) { return (input || output) ? File::Seek(pos, mode) : DualPipe_Seek(dp, pos, mode); }
  48    uint Tell() { return (input || output) ? File::Tell() : DualPipe_Tell(dp); }
  49    bool Eof() { return DualPipe_Eof(dp); }
  50    uint GetSize() { return (input || output) ? File::GetSize() : DualPipe_GetSize(dp); }
  51
  52 public:
  53    bool Peek() { return DualPipe_Peek(dp); }
  54    void Terminate() { DualPipe_Terminate(dp); }
  55    int GetExitCode() { return DualPipe_GetExitCode(dp); }
  56    int GetProcessID() { return DualPipe_GetProcessID(dp); }
  57    void Wait() { DualPipe_Wait(dp); }
  58
  59    // Return true on getting EOF or new line
  60    bool GetLinePeek(char * s, int max, int * charsRead)
  61    {
  62       char ch = 0;
  63       int c = 0;
  64       while(c < max-1 && Peek() && Getc(&ch) && ch != '\n')
  65          if(ch != '\r')
  66             s[c++] = ch;
  67       s[c] = '\0';
  68       *charsRead = c;
  69       return Eof() || ch == '\n';
  70    }
  71 };
  72
  73 public DualPipe DualPipeOpenf(PipeOpenMode mode, const char * command, ...)
  74 {
  75    char commandLine[MAX_F_STRING];
  76    va_list args;
  77    va_start(args, command);
  78    vsnprintf(commandLine, sizeof(commandLine), command, args);
  79    commandLine[sizeof(commandLine)-1] = 0;
  80    va_end(args);
  81    return DualPipeOpen(mode, commandLine);
  82 }
  83
  84 public DualPipe DualPipeOpen(PipeOpenMode mode, const char * commandLine)
  85 {
  86    void * input, * output;
  87    void * f = _DualPipeOpen(mode, commandLine, null, &input, &output);
  88    if(f)
  89       return DualPipe { dp = f, input = input, output = output };
  90    return null;
  91 }
  92
  93 public DualPipe DualPipeOpenEnvf(PipeOpenMode mode, const char * env, const char * command, ...)
  94 {
  95    char commandLine[MAX_F_STRING];
  96    va_list args;
  97    va_start(args, command);
  98    vsnprintf(commandLine, sizeof(commandLine), command, args);
  99    commandLine[sizeof(commandLine)-1] = 0;
 100    va_end(args);
 101    return DualPipeOpenEnv(mode, env, commandLine);
 102 }
 103
 104 public DualPipe DualPipeOpenEnv(PipeOpenMode mode, const char * env, const char * commandLine)
 105 {
 106    void * input, * output;
 107    void * f = _DualPipeOpen(mode, commandLine, env, &input, &output);
 108    if(f)
 109       return DualPipe { dp = f, input = input, output = output };
 110    return null;
 111 }