ExternalStream.st
changeset 20997 51ce73a25e29
parent 20987 35fce561fb6f
child 20998 a555cd085aa5
equal deleted inserted replaced
20996:3cb1110e6967 20997:51ce73a25e29
   402                 __offs ++;                              \
   402                 __offs ++;                              \
   403                 continue;                               \
   403                 continue;                               \
   404             }                                           \
   404             }                                           \
   405             CLEAR_ERRNO;                                \
   405             CLEAR_ERRNO;                                \
   406             {                                           \
   406             {                                           \
   407               int res = 0;                              \
   407               int res = -1, ok = 0;                             \
   408               if ((handleType == @symbol(socketFilePointer) && (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res), 1)) \
   408               if ((handleType == @symbol(socketFilePointer) && ((ok = ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res) == 0), 1)) \
   409                   || (handleType == @symbol(socketHandle) && (ioctlsocket((SOCKET)(f), FIONREAD, &res), 1)) \
   409                   || (handleType == @symbol(socketHandle) && ((ok = ioctlsocket((SOCKET)(f), FIONREAD, &res) == 0), 1)) \
   410                   || (handleType == @symbol(pipeFilePointer) && (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0), 1))) { \
   410                   || (handleType == @symbol(pipeFilePointer) && ((ok = PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0)), 1))) { \
       
   411                   if (!ok) { (ret) = -1; break };       \ 
   411                   if (res > 0) {                        \
   412                   if (res > 0) {                        \
   412                       if (res > ((cnt)-__offs))         \
   413                       if (res > ((cnt)-__offs))         \
   413                           res = (cnt)-__offs;           \
   414                           res = (cnt)-__offs;           \
   414                       READ((ret), f, (buf)+__offs, res, handleType); \
   415                       READ((ret), f, (buf)+__offs, res, handleType); \
   415                   } else {                              \
   416                   } else {                              \
   416                       (ret) = 0;                        \
   417                       (ret) = res;                      \
   417                       break;                            \
   418                       break;                            \
   418                   }                                     \
   419                   }                                     \
   419               } else {                                  \
   420               } else {                                  \
   420                   READ((ret), f, (buf)+__offs, (cnt)-__offs, handleType); \
   421                   READ((ret), f, (buf)+__offs, (cnt)-__offs, handleType); \
   421               }                                         \
   422               }                                         \
   422             }                                           \
   423             }                                           \
   423             if ((ret) <= 0) {                           \
   424             if ((ret) <= 0) {                           \
   424                 if (ret < 0 && __threadErrno == EINTR)  \
   425                 if ((ret) < 0 && __threadErrno == EINTR)\
   425                     continue;                           \
   426                     continue;                           \
   426                 break;                                  \
   427                 break;                                  \
   427             }                                           \
   428             }                                           \
   428             __offs += (ret);                            \
   429             __offs += (ret);                            \
   429         }                                               \
   430         }                                               \
   475                 int l;                                  \
   476                 int l;                                  \
   476                 CLEAR_ERRNO;                            \
   477                 CLEAR_ERRNO;                            \
   477                 l = (cnt)-__offs;                       \
   478                 l = (cnt)-__offs;                       \
   478                 if ( l > IO_BUFFER_SIZE)                \
   479                 if ( l > IO_BUFFER_SIZE)                \
   479                   l = IO_BUFFER_SIZE;                   \
   480                   l = IO_BUFFER_SIZE;                   \
   480                 READ((ret),f, __buf, l, handleType);                  \
   481                 READ((ret),f, __buf, l, handleType);    \
   481                 if ((ret) <= 0) {                       \
   482                 if ((ret) <= 0) {                       \
   482                     if ((ret) < 0 && __threadErrno == EINTR) {  \
   483                     if ((ret) < 0 && __threadErrno == EINTR) {  \
   483                         continue;                       \
   484                         continue;                       \
   484                     }                                   \
   485                     }                                   \
   485                     break;                              \
   486                     break;                              \
   486                 }                                       \
   487                 }                                       \
   487             }                                           \
   488             }                                           \
   488             if ((ret) > 0 ) {                           \
   489             if ((ret) > 0 ) {                           \
   489                 /* refetch */                               \
   490                 /* refetch */                               \
   490                 buf = (char *)(obj);               \
   491                 buf = (char *)(obj);                        \
   491                 memcpy((buf)+__ooffs+__offs,__buf,(ret));   \
   492                 memcpy((buf)+__ooffs+__offs,__buf,(ret));   \
   492                 __offs += (ret);                            \
   493                 __offs += (ret);                            \
   493             } else {                                        \
   494             } else {                                        \
   494                 (ret) = 0;                                  \
   495                 (ret) = 0;                                  \
   495             }                                               \
   496             }                                               \
   513             if ((ret) < 0) {                         \
   514             if ((ret) < 0) {                         \
   514                 if (ferror(f)) {                     \
   515                 if (ferror(f)) {                     \
   515                     if (__threadErrno == EINTR) {    \
   516                     if (__threadErrno == EINTR) {    \
   516                         clearerr(f);                 \
   517                         clearerr(f);                 \
   517                         /* refetch */                \
   518                         /* refetch */                \
   518                         buf = (char *)(obj);\
   519                         buf = (char *)(obj);         \
   519                         continue;                    \
   520                         continue;                    \
   520                     }                                \
   521                     }                                \
   521                 } else {                             \
   522                 } else {                             \
   522                     (ret) = 0;                       \
   523                     (ret) = 0;                       \
   523                 }                                    \
   524                 }                                    \
   538                 (ret) = 1;                           \
   539                 (ret) = 1;                           \
   539                 __offs++;                            \
   540                 __offs++;                            \
   540                 continue;                            \
   541                 continue;                            \
   541             }                                        \
   542             }                                        \
   542             {                                        \
   543             {                                        \
   543                 int res = 0;                         \
   544                 int res = -1, ok = 0;                \
   544                 int l = (cnt)-__offs;                \
   545                 int l = (cnt)-__offs;                \
   545                 CLEAR_ERRNO;                         \
   546                 CLEAR_ERRNO;                         \
   546                 if (l > IO_BUFFER_SIZE)              \
   547                 if (l > IO_BUFFER_SIZE) l = IO_BUFFER_SIZE;              \
   547                     l = IO_BUFFER_SIZE;              \
   548                 if ((handleType == @symbol(socketFilePointer) && ((ok = ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res) == 0), 1)) \
   548                 if ((handleType == @symbol(socketFilePointer) && (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)), FIONREAD, &res), 1)) \
   549                     || (handleType == @symbol(socketHandle) && ((ok = ioctlsocket((SOCKET)(f), FIONREAD, &res) == 0), 1)) \
   549                     || (handleType == @symbol(socketHandle) && (ioctlsocket((SOCKET)(f), FIONREAD, &res), 1)) \
   550                     || (handleType == @symbol(pipeFilePointer) && ((ok = PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0)), 1))) { \
   550                     || (handleType == @symbol(pipeFilePointer) && (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0,0,0,&res,0), 1))) { \
   551                    if (!ok) { (ret) = -1; break };  \ 
   551                     if (res > 0) {                   \
   552                    if (res > 0) {                   \
   552                         if (res > l) res = l;        \
   553                         if (res > l) res = l;       \
   553                         READ((ret), f, __buf, res, handleType); \
   554                         READ((ret), f, __buf, res, handleType); \
   554                     } else {                         \
   555                     } else {                         \
   555                         (ret) = 0;                   \
   556                         (ret) = res;                 \
   556                         break;                       \
   557                         break;                       \
   557                     }                                \
   558                     }                                \
   558                 } else {                             \
   559                 } else {                             \
   559                     READ((ret), f, __buf, l, handleType); \
   560                     READ((ret), f, __buf, l, handleType); \
   560                 }                                     \
   561                 }                                     \
   561                 if ((ret) <= 0) {                     \
   562                 if ((ret) <= 0) {                     \
   562                     if (ret < 0 && __threadErrno == EINTR) \
   563                     if ((ret) < 0 && __threadErrno == EINTR) \
   563                         continue;                       \
   564                         continue;                       \
   564                     break;                              \
   565                     break;                              \
   565                 }                                       \
   566                 }                                       \
   566             }                                           \
   567             }                                           \
   567             if ((ret) > 0) {                            \
   568             if ((ret) > 0) {                            \
   583             CLEAR_ERRNO;                                \
   584             CLEAR_ERRNO;                                \
   584             ret = putc(*(buf), f);                      \
   585             ret = putc(*(buf), f);                      \
   585             if ((ret) >= 0) {                           \
   586             if ((ret) >= 0) {                           \
   586                 (ret) = 1;                              \
   587                 (ret) = 1;                              \
   587             } else if (ferror(f)) {                     \
   588             } else if (ferror(f)) {                     \
   588                 if (__threadErrno == EINTR) {                   \
   589                 if (__threadErrno == EINTR) {           \
   589                     clearerr(f);                        \
   590                     clearerr(f);                        \
   590                     continue;                           \
   591                     continue;                           \
   591                 }                                       \
   592                 }                                       \
   592             } else                                      \
   593             } else                                      \
   593                 (ret) = 0;                              \
   594                 (ret) = 0;                              \
   594             break;                                      \
   595             break;                                      \
   595         }                                               \
   596         }                                               \
   596     } else {                                            \
   597     } else {                                            \
   597         for (;;) {                                      \
   598         for (;;) {                                      \
   598             CLEAR_ERRNO;                                \
   599             CLEAR_ERRNO;                                \
   599             WRITE(ret,f, buf, 1, handleType);                       \
   600             WRITE(ret,f, buf, 1, handleType);           \
   600             if ((ret) >= 0 || __threadErrno != EINTR)           \
   601             if ((ret) >= 0 || __threadErrno != EINTR)   \
   601                 break;                                  \
   602                 break;                                  \
   602         }                                               \
   603         }                                               \
   603    }
   604    }
   604 
   605 
   605 # define __WRITEBYTES__(ret, f, buf, cnt, isBuffered, handleType)   \
   606 # define __WRITEBYTES__(ret, f, buf, cnt, isBuffered, handleType)   \
   609         while (__offs < (cnt)) {                        \
   610         while (__offs < (cnt)) {                        \
   610             CLEAR_ERRNO;                                \
   611             CLEAR_ERRNO;                                \
   611             (ret) = fwrite((buf)+__offs, 1, (cnt)-__offs, f);\
   612             (ret) = fwrite((buf)+__offs, 1, (cnt)-__offs, f);\
   612             if ((ret) <= 0) {                           \
   613             if ((ret) <= 0) {                           \
   613                 if (ferror(f)) {                        \
   614                 if (ferror(f)) {                        \
   614                     if (__threadErrno == EINTR) {               \
   615                     if (__threadErrno == EINTR) {       \
   615                         clearerr(f);                    \
   616                         clearerr(f);                    \
   616                         continue;                       \
   617                         continue;                       \
   617                     }                                   \
   618                     }                                   \
   618                     break;                              \
   619                     break;                              \
   619                 } else {                                \
   620                 } else {                                \
   626             (ret) = __offs;                             \
   627             (ret) = __offs;                             \
   627     } else {                                            \
   628     } else {                                            \
   628         int __offs = 0;                                 \
   629         int __offs = 0;                                 \
   629         while (__offs < (cnt)) {                        \
   630         while (__offs < (cnt)) {                        \
   630             CLEAR_ERRNO;                                \
   631             CLEAR_ERRNO;                                \
   631             WRITE(ret,f, (buf)+__offs, (cnt)-__offs, handleType);   \
   632             WRITE((ret),f, (buf)+__offs, (cnt)-__offs, handleType);   \
   632             if (ret <= 0) {                             \
   633             if ((ret) <= 0) {                             \
   633                 if (ret < 0 && __threadErrno == EINTR) { \
   634                 if ((ret) < 0 && __threadErrno == EINTR) { \
   634                     continue;                           \
   635                     continue;                           \
   635                 }                                       \
   636                 }                                       \
   636                 break;                                  \
   637                 break;                                  \
   637             }                                           \
   638             }                                           \
   638             __offs += (ret);                            \
   639             __offs += (ret);                            \
   654             ret = fwrite((buf)+__ooffs+__offs, 1, (cnt)-__offs, f); \
   655             ret = fwrite((buf)+__ooffs+__offs, 1, (cnt)-__offs, f); \
   655             if ((ret) <= 0) {                           \
   656             if ((ret) <= 0) {                           \
   656                 if (ferror(f)) {                        \
   657                 if (ferror(f)) {                        \
   657                     if (__threadErrno == EINTR) {       \
   658                     if (__threadErrno == EINTR) {       \
   658                         /* refetch */                   \
   659                         /* refetch */                   \
   659                         buf = (char *)(obj);   \
   660                         buf = (char *)(obj);            \
   660                         clearerr(f);                    \
   661                         clearerr(f);                    \
   661                         continue;                       \
   662                         continue;                       \
   662                     }                                   \
   663                     }                                   \
   663                     break;                              \
   664                     break;                              \
   664                 } else {                                \
   665                 } else {                                \
   676             CLEAR_ERRNO;                                \
   677             CLEAR_ERRNO;                                \
   677             l = (cnt)-__offs;                           \
   678             l = (cnt)-__offs;                           \
   678             if ( l > IO_BUFFER_SIZE)                    \
   679             if ( l > IO_BUFFER_SIZE)                    \
   679               l = IO_BUFFER_SIZE;                       \
   680               l = IO_BUFFER_SIZE;                       \
   680             /* refetch */                               \
   681             /* refetch */                               \
   681             buf = (char *)(obj);               \
   682             buf = (char *)(obj);                        \
   682             memcpy(__buf,(buf)+__ooffs+__offs,l);       \
   683             memcpy(__buf,(buf)+__ooffs+__offs,l);       \
   683             WRITE(ret,f, __buf, l, handleType);                     \
   684             WRITE(ret,f, __buf, l, handleType);         \
   684             if (ret <= 0) {                             \
   685             if ((ret) <= 0) {                           \
   685                 if (ret < 0 && __threadErrno == EINTR) {        \
   686                 if ((ret) < 0 && __threadErrno == EINTR) { \
   686                     continue;                           \
   687                     continue;                           \
   687                 }                                       \
   688                 }                                       \
   688                 break;                                  \
   689                 break;                                  \
   689             }                                           \
   690             }                                           \
   690             __offs += (ret);                            \
   691             __offs += (ret);                            \