BOOL hb_dynsymIsFunction( PHB_DYNS pDynSym ) { HB_TRACE(HB_TR_DEBUG, ("hb_dynsymIsFunction(%p)", pDynSym)); return pDynSym->pSymbol->value.pFunPtr != NULL; }
static void hb_gt_cgi_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { int iColor; HB_BYTE bAttr; HB_USHORT usChar; int iLineFeed, iHeight, iWidth, iLen; PHB_GTCGI pGTCGI; HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); pGTCGI = HB_GTCGI_GET( pGT ); HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); iLineFeed = iLen = 0; if( pGTCGI->iRow != iRow ) { iLineFeed = pGTCGI->iRow < iRow ? iRow - pGTCGI->iRow : 1; pGTCGI->iLastCol = pGTCGI->iCol = iCol = 0; iSize = iWidth; } else if( pGTCGI->iCol < iCol ) { iSize += iCol - pGTCGI->iCol; iCol = pGTCGI->iCol; } else if( pGTCGI->iCol > iCol ) { iLineFeed = 1; iCol = pGTCGI->iCol = pGTCGI->iLastCol = 0; iSize = iWidth; } while( iSize > 0 && iCol + iSize > pGTCGI->iLastCol && HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iSize - 1, &iColor, &bAttr, &usChar ) ) { if( usChar != ' ' ) break; --iSize; } if( iSize > 0 ) { PHB_CODEPAGE cdpTerm = HB_GTSELF_TERMCP( pGT ); int iIndex = 0; while( --iLineFeed >= 0 ) hb_gt_cgi_newLine( pGTCGI ); pGTCGI->iRow = iRow; while( iLen < iSize ) { if( ! HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &iColor, &bAttr, &usChar ) ) break; iIndex += ( int ) hb_cdpTextPutU16( cdpTerm, pGTCGI->sLineBuf + iIndex, pGTCGI->iLineBufSize - iIndex, usChar ); ++iLen; ++iCol; } if( iIndex ) { hb_gt_cgi_termOut( pGTCGI, pGTCGI->sLineBuf, iIndex ); pGTCGI->iCol = iCol; if( pGTCGI->iCol > pGTCGI->iLastCol ) pGTCGI->iLastCol = pGTCGI->iCol; } } }
HB_FHANDLE hb_fsProcessOpen( const char * pszFileName, HB_FHANDLE * phStdin, HB_FHANDLE * phStdout, HB_FHANDLE * phStderr, HB_BOOL fDetach, HB_ULONG * pulPID ) { HB_FHANDLE hPipeIn [ 2 ] = { FS_ERROR, FS_ERROR }, hPipeOut[ 2 ] = { FS_ERROR, FS_ERROR }, hPipeErr[ 2 ] = { FS_ERROR, FS_ERROR }; HB_FHANDLE hResult = FS_ERROR; HB_BOOL fError = HB_FALSE; HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessOpen(%s, %p, %p, %p, %d, %p)", pszFileName, phStdin, phStdout, phStderr, fDetach, pulPID ) ); if( phStdin != NULL ) fError = ! hb_fsPipeCreate( hPipeIn ); if( ! fError && phStdout != NULL ) fError = ! hb_fsPipeCreate( hPipeOut ); if( ! fError && phStderr != NULL ) { if( phStdout == phStderr ) { hPipeErr[ 0 ] = hPipeOut[ 0 ]; hPipeErr[ 1 ] = hPipeOut[ 1 ]; } else fError = ! hb_fsPipeCreate( hPipeErr ); } if( ! fError ) { #if defined( HB_OS_WIN ) PROCESS_INFORMATION pi; STARTUPINFO si; DWORD dwFlags = 0; LPTSTR lpCommand = HB_CHARDUP( pszFileName ); # if ! defined( HB_OS_WIN_CE ) if( phStdin != NULL ) SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 1 ] ), HANDLE_FLAG_INHERIT, 0 ); if( phStdout != NULL ) SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 0 ] ), HANDLE_FLAG_INHERIT, 0 ); if( phStderr != NULL && phStdout != phStderr ) SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 0 ] ), HANDLE_FLAG_INHERIT, 0 ); # endif memset( &pi, 0, sizeof( pi ) ); memset( &si, 0, sizeof( si ) ); si.cb = sizeof( si ); # ifdef STARTF_USESTDHANDLES si.dwFlags = STARTF_USESTDHANDLES; # endif if( fDetach ) { # ifdef STARTF_USESHOWWINDOW si.dwFlags |= STARTF_USESHOWWINDOW; # endif si.wShowWindow = SW_HIDE; si.hStdInput = ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] ); si.hStdOutput = ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] ); si.hStdError = ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] ); # ifdef DETACHED_PROCESS dwFlags |= DETACHED_PROCESS; # endif } else { si.hStdInput = phStdin ? ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] ) : GetStdHandle( STD_INPUT_HANDLE ); si.hStdOutput = phStdout ? ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] ) : GetStdHandle( STD_OUTPUT_HANDLE ); si.hStdError = phStderr ? ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] ) : GetStdHandle( STD_ERROR_HANDLE ); } fError = ! CreateProcess( NULL, /* lpAppName */ lpCommand, NULL, /* lpProcessAttr */ NULL, /* lpThreadAttr */ TRUE, /* bInheritHandles */ dwFlags, /* dwCreationFlags */ NULL, /* lpEnvironment */ NULL, /* lpCurrentDirectory */ &si, &pi ); hb_fsSetIOError( ! fError, 0 ); hb_xfree( lpCommand ); if( ! fError ) { if( phStdin != NULL ) { *phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ]; hPipeIn[ 1 ] = FS_ERROR; } if( phStdout != NULL ) { *phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ]; hPipeOut[ 0 ] = FS_ERROR; } if( phStderr != NULL ) { *phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ]; hPipeErr[ 0 ] = FS_ERROR; } if( pulPID ) *pulPID = pi.dwProcessId; CloseHandle( pi.hThread ); hResult = ( HB_FHANDLE ) pi.hProcess; } #elif defined( HB_OS_UNIX ) && \ ! defined( HB_OS_VXWORKS ) && ! defined( HB_OS_SYMBIAN ) pid_t pid = fork(); if( pid == -1 ) fError = HB_TRUE; else if( pid != 0 ) /* parent process */ { if( phStdin != NULL ) { *phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ]; hPipeIn[ 1 ] = FS_ERROR; } if( phStdout != NULL ) { *phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ]; hPipeOut[ 0 ] = FS_ERROR; } if( phStderr != NULL ) { *phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ]; hPipeErr[ 0 ] = FS_ERROR; } if( pulPID ) *pulPID = pid; hResult = ( HB_FHANDLE ) pid; } else /* child process */ { if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) ) { HB_FHANDLE hNull = open( "/dev/null", O_RDWR ); if( ! phStdin ) dup2( hNull, 0 ); if( ! phStdout ) dup2( hNull, 1 ); if( ! phStderr ) dup2( hNull, 2 ); if( hNull != FS_ERROR ) hb_fsClose( hNull ); } if( phStdin != NULL ) { dup2( hPipeIn[ 0 ], 0 ); hb_fsClose( hPipeIn[ 1 ] ); } if( phStdout != NULL ) { dup2( hPipeOut[ 1 ], 1 ); hb_fsClose( hPipeOut[ 0 ] ); } if( phStderr != NULL ) { dup2( hPipeErr[ 1 ], 2 ); if( phStdout != phStderr ) hb_fsClose( hPipeErr[ 0 ] ); } /* close all non std* handles */ { int iMaxFD, i; iMaxFD = sysconf( _SC_OPEN_MAX ); if( iMaxFD < 3 ) iMaxFD = 1024; for( i = 3; i < iMaxFD; ++i ) hb_fsClose( i ); } /* reset extended process attributes */ ( void ) setuid( getuid() ); ( void ) setgid( getgid() ); /* execute command */ { char ** argv; argv = hb_buildArgs( pszFileName ); # if defined( __WATCOMC__ ) execvp( argv[ 0 ], ( const char ** ) argv ); # else execvp( argv[ 0 ], argv ); # endif hb_freeArgs( argv ); exit( -1 ); } } #elif defined( HB_OS_OS2 ) || defined( HB_OS_WIN ) int hStdIn, hStdOut, hStdErr; char ** argv; int pid; hStdIn = dup( 0 ); hStdOut = dup( 1 ); hStdErr = dup( 2 ); if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) ) { HB_FHANDLE hNull = open( "NUL:", O_RDWR ); if( ! phStdin ) dup2( hNull, 0 ); if( ! phStdout ) dup2( hNull, 1 ); if( ! phStderr ) dup2( hNull, 2 ); if( hNull != FS_ERROR ) close( hNull ); } if( phStdin != NULL ) dup2( hPipeIn[ 0 ], 0 ); if( phStdout != NULL ) dup2( hPipeOut[ 1 ], 1 ); if( phStderr != NULL ) dup2( hPipeErr[ 1 ], 2 ); argv = hb_buildArgs( pszFileName ); #if defined( _MSC_VER ) || defined( __LCC__ ) || \ defined( __XCC__ ) || defined( __POCC__ ) pid = _spawnvp( _P_NOWAIT, argv[ 0 ], argv ); #elif defined( __MINGW32__ ) || defined( __WATCOMC__ ) pid = spawnvp( P_NOWAIT, argv[ 0 ], ( const char * const * ) argv ); #else pid = spawnvp( P_NOWAIT, argv[ 0 ], ( char * const * ) argv ); #endif hb_freeArgs( argv ); dup2( hStdIn, 0 ); close( hStdIn ); dup2( hStdOut, 1 ); close( hStdOut ); dup2( hStdErr, 2 ); close( hStdErr ); if( pid < 0 ) fError = HB_TRUE; else if( pid != 0 ) /* parent process */ { if( phStdin != NULL ) { *phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ]; hPipeIn[ 1 ] = FS_ERROR; } if( phStdout != NULL ) { *phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ]; hPipeOut[ 0 ] = FS_ERROR; } if( phStderr != NULL ) { *phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ]; hPipeErr[ 0 ] = FS_ERROR; } if( pulPID ) *pulPID = pid; hResult = ( HB_FHANDLE ) pid; } #else int iTODO; /* TODO: for given platform */ HB_SYMBOL_UNUSED( pszFileName ); HB_SYMBOL_UNUSED( fDetach ); HB_SYMBOL_UNUSED( pulPID ); hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); #endif } hb_fsSetIOError( ! fError, 0 ); if( hPipeIn[ 0 ] != FS_ERROR ) hb_fsClose( hPipeIn[ 0 ] ); if( hPipeIn[ 1 ] != FS_ERROR ) hb_fsClose( hPipeIn[ 1 ] ); if( hPipeOut[ 0 ] != FS_ERROR ) hb_fsClose( hPipeOut[ 0 ] ); if( hPipeOut[ 1 ] != FS_ERROR ) hb_fsClose( hPipeOut[ 1 ] ); if( phStdout != phStderr ) { if( hPipeErr[ 0 ] != FS_ERROR ) hb_fsClose( hPipeErr[ 0 ] ); if( hPipeErr[ 1 ] != FS_ERROR ) hb_fsClose( hPipeErr[ 1 ] ); } return hResult; }
int ct_getatlike (void) { HB_TRACE(HB_TR_DEBUG, ("ct_getatlike()")); return (siAtLikeMode); }
char ct_getatlikechar (void) { HB_TRACE(HB_TR_DEBUG, ("ct_getatlikechar()")); return (scAtLikeChar); }
int ct_getref (void) { HB_TRACE(HB_TR_DEBUG, ("ct_getref()")); return (siRefSwitch); }
int ct_getatmupa (void) { HB_TRACE(HB_TR_DEBUG, ("ct_getatmupa()")); return (siAtMupaSwitch); }
HB_FATTR hb_fsAttrToRaw( HB_FATTR nAttr ) { HB_FATTR raw_attr; HB_TRACE( HB_TR_DEBUG, ( "hb_fsAttrToRaw(%u)", nAttr ) ); #if defined( HB_OS_DOS ) raw_attr = 0; if( nAttr & HB_FA_ARCHIVE ) raw_attr |= FA_ARCH; if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FA_DIREC; if( nAttr & HB_FA_HIDDEN ) raw_attr |= FA_HIDDEN; if( nAttr & HB_FA_READONLY ) raw_attr |= FA_RDONLY; if( nAttr & HB_FA_LABEL ) raw_attr |= FA_LABEL; if( nAttr & HB_FA_SYSTEM ) raw_attr |= FA_SYSTEM; #elif defined( HB_OS_OS2 ) raw_attr = 0; if( nAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ARCHIVED; if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_DIRECTORY; if( nAttr & HB_FA_HIDDEN ) raw_attr |= FILE_HIDDEN; if( nAttr & HB_FA_READONLY ) raw_attr |= FILE_READONLY; if( nAttr & HB_FA_SYSTEM ) raw_attr |= FILE_SYSTEM; #elif defined( HB_OS_WIN ) raw_attr = 0; if( nAttr & HB_FA_ARCHIVE ) raw_attr |= FILE_ATTRIBUTE_ARCHIVE; if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_ATTRIBUTE_DIRECTORY; if( nAttr & HB_FA_HIDDEN ) raw_attr |= FILE_ATTRIBUTE_HIDDEN; if( nAttr & HB_FA_READONLY ) raw_attr |= FILE_ATTRIBUTE_READONLY; if( nAttr & HB_FA_SYSTEM ) raw_attr |= FILE_ATTRIBUTE_SYSTEM; if( nAttr & HB_FA_NORMAL ) raw_attr |= FILE_ATTRIBUTE_NORMAL; /* Note that FILE_ATTRIBUTE_NORMAL is not needed HB_FA_DEVICE not supported HB_FA_VOLCOMP needs to be checked */ if( nAttr & HB_FA_ENCRYPTED ) raw_attr |= FILE_ATTRIBUTE_ENCRYPTED; if( nAttr & HB_FA_TEMPORARY ) raw_attr |= FILE_ATTRIBUTE_TEMPORARY; if( nAttr & HB_FA_SPARSE ) raw_attr |= FILE_ATTRIBUTE_SPARSE_FILE; if( nAttr & HB_FA_REPARSE ) raw_attr |= FILE_ATTRIBUTE_REPARSE_POINT; if( nAttr & HB_FA_COMPRESSED ) raw_attr |= FILE_ATTRIBUTE_COMPRESSED; if( nAttr & HB_FA_OFFLINE ) raw_attr |= FILE_ATTRIBUTE_OFFLINE; if( nAttr & HB_FA_NOTINDEXED ) raw_attr |= 0x00002000; /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED not defined in some older winnt.h */ if( nAttr & HB_FA_VOLCOMP ) raw_attr |= 0x00008000; #elif defined( HB_OS_UNIX ) raw_attr = HB_FA_POSIX_ATTR( nAttr ); if( nAttr & HB_FA_FILE ) raw_attr |= S_IFREG; if( nAttr & HB_FA_DIRECTORY ) raw_attr |= S_IFDIR; if( nAttr & HB_FA_LINK ) raw_attr |= S_IFLNK; if( nAttr & HB_FA_CHRDEVICE ) raw_attr |= S_IFCHR; if( nAttr & HB_FA_BLKDEVICE ) raw_attr |= S_IFBLK; if( nAttr & HB_FA_FIFO ) raw_attr |= S_IFIFO; if( nAttr & HB_FA_SOCKET ) raw_attr |= S_IFSOCK; #else HB_SYMBOL_UNUSED( nAttr ); raw_attr = 0; #endif return raw_attr; }
static void hb_gt_std_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr ) { PHB_GTSTD pGTSTD; HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Init(%p,%p,%p,%p)", pGT, ( void * ) ( HB_PTRDIFF ) hFilenoStdin, ( void * ) ( HB_PTRDIFF ) hFilenoStdout, ( void * ) ( HB_PTRDIFF ) hFilenoStderr ) ); pGTSTD = ( PHB_GTSTD ) hb_xgrab( sizeof( HB_GTSTD ) ); memset( pGTSTD, 0, sizeof( HB_GTSTD ) ); HB_GTLOCAL( pGT ) = pGTSTD; pGTSTD->hStdin = hFilenoStdin; pGTSTD->hStdout = hFilenoStdout; pGTSTD->hStderr = hFilenoStderr; pGTSTD->fStdinConsole = hb_fsIsDevice( pGTSTD->hStdin ); pGTSTD->fStdoutConsole = hb_fsIsDevice( pGTSTD->hStdout ); pGTSTD->fStderrConsole = hb_fsIsDevice( pGTSTD->hStderr ); pGTSTD->szCrLf = hb_strdup( hb_conNewLine() ); pGTSTD->nCrLf = strlen( pGTSTD->szCrLf ); hb_fsSetDevMode( pGTSTD->hStdout, FD_BINARY ); HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); /* SA_NOCLDSTOP in #if is a hack to detect POSIX compatible environment */ #if defined( HB_HAS_TERMIOS ) && \ defined( SA_NOCLDSTOP ) if( pGTSTD->fStdinConsole ) { #if defined( SIGTTOU ) struct sigaction act, old; /* if( pGTSTD->saved_TIO.c_lflag & TOSTOP ) != 0 */ sigaction( SIGTTOU, NULL, &old ); memcpy( &act, &old, sizeof( struct sigaction ) ); act.sa_handler = sig_handler; /* do not use SA_RESTART - new Linux kernels will repeat the operation */ #if defined( SA_ONESHOT ) act.sa_flags = SA_ONESHOT; #elif defined( SA_RESETHAND ) act.sa_flags = SA_RESETHAND; #else act.sa_flags = 0; #endif sigaction( SIGTTOU, &act, 0 ); #endif s_fRestTTY = HB_TRUE; tcgetattr( pGTSTD->hStdin, &pGTSTD->saved_TIO ); memcpy( &pGTSTD->curr_TIO, &pGTSTD->saved_TIO, sizeof( struct termios ) ); /* atexit( restore_input_mode ); */ pGTSTD->curr_TIO.c_lflag &= ~( ICANON | ECHO ); pGTSTD->curr_TIO.c_iflag &= ~ICRNL; pGTSTD->curr_TIO.c_cc[ VMIN ] = 0; pGTSTD->curr_TIO.c_cc[ VTIME ] = 0; tcsetattr( pGTSTD->hStdin, TCSAFLUSH, &pGTSTD->curr_TIO ); #if defined( SIGTTOU ) act.sa_handler = SIG_DFL; sigaction( SIGTTOU, &old, NULL ); #endif pGTSTD->fRestTTY = s_fRestTTY; } #ifdef TIOCGWINSZ if( pGTSTD->fStdoutConsole ) { struct winsize win; if( ioctl( pGTSTD->hStdout, TIOCGWINSZ, ( char * ) &win ) != -1 ) { HB_GTSELF_RESIZE( pGT, win.ws_row, win.ws_col ); } } #endif #elif defined( HB_OS_WIN ) && ! defined( HB_OS_WIN_CE ) if( pGTSTD->fStdinConsole ) { SetConsoleMode( ( HANDLE ) hb_fsGetOsHandle( pGTSTD->hStdin ), 0x0000 ); } #endif HB_GTSELF_SETFLAG( pGT, HB_GTI_STDOUTCON, pGTSTD->fStdoutConsole ); HB_GTSELF_SETFLAG( pGT, HB_GTI_STDERRCON, pGTSTD->fStderrConsole && pGTSTD->fStdoutConsole ); }
static char * hb_fsReadLine( HB_FHANDLE hFileHandle, HB_ISIZ * plBuffLen, const char ** pTerm, HB_ISIZ * pnTermSizes, HB_ISIZ nTerms, HB_BOOL * pbFound, HB_BOOL * pbEOF ) { HB_ISIZ nPosTerm = 0, nPos, nPosition; int nTries; HB_ISIZ nRead = 0, nOffset, nSize; char * pBuff; HB_TRACE( HB_TR_DEBUG, ( "hb_fsReadLine(%p, %" HB_PFS "d, %p, %p, %" HB_PFS "d, %p, %p)", ( void * ) ( HB_PTRDIFF ) hFileHandle, *plBuffLen, pTerm, pnTermSizes, nTerms, pbFound, pbEOF ) ); *pbFound = HB_FALSE; *pbEOF = HB_FALSE; nTries = 0; nOffset = 0; nSize = *plBuffLen; if( *plBuffLen < 10 ) *plBuffLen = READING_BLOCK; pBuff = ( char * ) hb_xgrab( *plBuffLen + 1 ); do { if( nTries > 0 ) { /* pBuff can be enlarged to hold the line as needed.. */ nSize = ( *plBuffLen * ( nTries + 1 ) ) + 1; pBuff = ( char * ) hb_xrealloc( pBuff, nSize ); nOffset += nRead; } /* read from file */ nRead = hb_fsReadLarge( hFileHandle, pBuff + nOffset, nSize - nOffset ); /* scan the read buffer */ if( nRead > 0 ) { for( nPos = 0; nPos < nRead; nPos++ ) { for( nPosTerm = 0; nPosTerm < nTerms; nPosTerm++ ) { /* Compare with the LAST terminator byte */ if( pBuff[ nOffset + nPos ] == pTerm[ nPosTerm ][ pnTermSizes[ nPosTerm ] - 1 ] && ( pnTermSizes[ nPosTerm ] - 1 ) <= ( nPos + nOffset ) ) { *pbFound = HB_TRUE; for( nPosition = 0; nPosition < ( pnTermSizes[ nPosTerm ] - 1 ); nPosition++ ) { if( pTerm[ nPosTerm ][ nPosition ] != pBuff[ nOffset + ( nPos - pnTermSizes[ nPosTerm ] ) + nPosition + 1 ] ) { *pbFound = HB_FALSE; break; } } if( *pbFound ) break; } } if( *pbFound ) break; } if( *pbFound ) { *plBuffLen = nOffset + nPos - pnTermSizes[ nPosTerm ] + 1; pBuff[ *plBuffLen ] = '\0'; /* Set handle pointer in the end of the line */ hb_fsSeekLarge( hFileHandle, ( ( nRead - nPos ) * -1 ) + 1, FS_RELATIVE ); return pBuff; } } else { if( ! *pbFound ) { if( nTries == 0 ) { pBuff[ 0 ] = '\0'; *plBuffLen = 0; } else { pBuff[ nOffset + nRead ] = '\0'; *plBuffLen = nOffset + nRead; } *pbEOF = HB_TRUE; } } nTries++; } while( ! *pbFound && nRead > 0 ); return pBuff; }
HB_FATTR hb_fsAttrFromRaw( HB_FATTR raw_attr ) { HB_FATTR nAttr; HB_TRACE( HB_TR_DEBUG, ( "hb_fsAttrFromRaw(%u)", raw_attr ) ); #if defined( HB_OS_DOS ) nAttr = 0; if( raw_attr & FA_ARCH ) nAttr |= HB_FA_ARCHIVE; if( raw_attr & FA_DIREC ) nAttr |= HB_FA_DIRECTORY; if( raw_attr & FA_HIDDEN ) nAttr |= HB_FA_HIDDEN; if( raw_attr & FA_RDONLY ) nAttr |= HB_FA_READONLY; if( raw_attr & FA_LABEL ) nAttr |= HB_FA_LABEL; if( raw_attr & FA_SYSTEM ) nAttr |= HB_FA_SYSTEM; #elif defined( HB_OS_OS2 ) nAttr = 0; if( raw_attr & FILE_ARCHIVED ) nAttr |= HB_FA_ARCHIVE; if( raw_attr & FILE_DIRECTORY ) nAttr |= HB_FA_DIRECTORY; if( raw_attr & FILE_HIDDEN ) nAttr |= HB_FA_HIDDEN; if( raw_attr & FILE_READONLY ) nAttr |= HB_FA_READONLY; if( raw_attr & FILE_SYSTEM ) nAttr |= HB_FA_SYSTEM; #elif defined( HB_OS_WIN ) nAttr = 0; if( raw_attr & FILE_ATTRIBUTE_ARCHIVE ) nAttr |= HB_FA_ARCHIVE; if( raw_attr & FILE_ATTRIBUTE_DIRECTORY ) nAttr |= HB_FA_DIRECTORY; if( raw_attr & FILE_ATTRIBUTE_HIDDEN ) nAttr |= HB_FA_HIDDEN; if( raw_attr & FILE_ATTRIBUTE_READONLY ) nAttr |= HB_FA_READONLY; if( raw_attr & FILE_ATTRIBUTE_SYSTEM ) nAttr |= HB_FA_SYSTEM; if( raw_attr & FILE_ATTRIBUTE_NORMAL ) nAttr |= HB_FA_NORMAL; /* Note that FILE_ATTRIBUTE_NORMAL is not needed HB_FA_DEVICE not supported HB_FA_VOLCOMP needs to be checked */ if( raw_attr & FILE_ATTRIBUTE_ENCRYPTED ) nAttr |= HB_FA_ENCRYPTED; if( raw_attr & FILE_ATTRIBUTE_TEMPORARY ) nAttr |= HB_FA_TEMPORARY; if( raw_attr & FILE_ATTRIBUTE_SPARSE_FILE ) nAttr |= HB_FA_SPARSE; if( raw_attr & FILE_ATTRIBUTE_REPARSE_POINT ) nAttr |= HB_FA_REPARSE; if( raw_attr & FILE_ATTRIBUTE_COMPRESSED ) nAttr |= HB_FA_COMPRESSED; if( raw_attr & FILE_ATTRIBUTE_OFFLINE ) nAttr |= HB_FA_OFFLINE; /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED */ /* not defined in some older winnt.h */ if( raw_attr & 0x00002000 ) nAttr |= HB_FA_NOTINDEXED; if( raw_attr & 0x00008000 ) nAttr |= HB_FA_VOLCOMP; #elif defined( HB_OS_UNIX ) nAttr = ( ( raw_attr & S_IXOTH ) ? HB_FA_XOTH : 0 ) | ( ( raw_attr & S_IWOTH ) ? HB_FA_WOTH : 0 ) | ( ( raw_attr & S_IROTH ) ? HB_FA_ROTH : 0 ) | ( ( raw_attr & S_IXGRP ) ? HB_FA_XGRP : 0 ) | ( ( raw_attr & S_IWGRP ) ? HB_FA_WGRP : 0 ) | ( ( raw_attr & S_IRGRP ) ? HB_FA_RGRP : 0 ) | ( ( raw_attr & S_IXUSR ) ? HB_FA_XUSR : 0 ) | ( ( raw_attr & S_IWUSR ) ? HB_FA_WUSR : 0 ) | ( ( raw_attr & S_IRUSR ) ? HB_FA_RUSR : 0 ) | ( ( raw_attr & S_ISVTX ) ? HB_FA_SVTX : 0 ) | ( ( raw_attr & S_ISGID ) ? HB_FA_SGID : 0 ) | ( ( raw_attr & S_ISUID ) ? HB_FA_SUID : 0 ); if( S_ISREG( raw_attr ) ) nAttr |= HB_FA_FILE; if( S_ISDIR( raw_attr ) ) nAttr |= HB_FA_DIRECTORY; if( S_ISLNK( raw_attr ) ) nAttr |= HB_FA_LINK; if( S_ISCHR( raw_attr ) ) nAttr |= HB_FA_CHRDEVICE; if( S_ISBLK( raw_attr ) ) nAttr |= HB_FA_BLKDEVICE; if( S_ISFIFO( raw_attr ) ) nAttr |= HB_FA_FIFO; #if ! defined( HB_OS_VXWORKS ) if( S_ISSOCK( raw_attr ) ) nAttr |= HB_FA_SOCKET; #endif #else nAttr = 0; HB_SYMBOL_UNUSED( raw_attr ); #endif return nAttr; }
void hb_dynsymSetAreaHandle( PHB_DYNS pDynSym, const int iArea ) { HB_TRACE(HB_TR_DEBUG, ("hb_dynsymSetAreaHandle(%p,%d)", pDynSym, iArea)); pDynSym->hArea = (HB_HANDLE) iArea; }
HB_HANDLE hb_dynsymAreaHandle( PHB_DYNS pDynSym ) { HB_TRACE(HB_TR_DEBUG, ("hb_dynsymAreaHandle(%p)", pDynSym)); return pDynSym->hArea; }
HB_HANDLE hb_dynsymMemvarHandle( PHB_DYNS pDynSym ) { HB_TRACE(HB_TR_DEBUG, ("hb_dynsymMemvarHandle(%p)", pDynSym)); return pDynSym->hMemvar; }
static HRESULT _get_default_sink( IDispatch * iDisp, const char * szEvent, IID * piid ) { ITypeInfo * iTI; ITypeInfo * iTISink; TYPEATTR * pTypeAttr; HREFTYPE hRefType; HRESULT hr; int iFlags, i, j; if( ! szEvent ) { IProvideClassInfo2 * iPCI2; IProvideClassInfo * iPCI; /* Method 1: using IProvideClassInfo2 */ hr = HB_VTBL( iDisp )->QueryInterface( HB_THIS_( iDisp ) HB_ID_REF( IID_IProvideClassInfo2 ), ( void ** ) ( void * ) &iPCI2 ); if( hr == S_OK ) { HB_TRACE( HB_TR_DEBUG, ( "_get_default_sink IProvideClassInfo2 OK" ) ); hr = HB_VTBL( iPCI2 )->GetGUID( HB_THIS_( iPCI2 ) GUIDKIND_DEFAULT_SOURCE_DISP_IID, piid ); HB_VTBL( iPCI2 )->Release( HB_THIS( iPCI2 ) ); if( hr == S_OK ) return S_OK; } else HB_TRACE( HB_TR_DEBUG, ( "_get_default_sink IProvideClassInfo2 obtain error %08lX", hr ) ); /* Method 2: using IProvideClassInfo and searching for default source in ITypeInfo */ hr = HB_VTBL( iDisp )->QueryInterface( HB_THIS_( iDisp ) HB_ID_REF( IID_IProvideClassInfo ), ( void ** ) ( void * ) &iPCI ); if( hr == S_OK ) { HB_TRACE( HB_TR_DEBUG, ( "_get_default_sink IProvideClassInfo OK" ) ); hr = HB_VTBL( iPCI )->GetClassInfo( HB_THIS_( iPCI ) & iTI ); if( hr == S_OK ) { hr = HB_VTBL( iTI )->GetTypeAttr( HB_THIS_( iTI ) & pTypeAttr ); if( hr == S_OK ) { for( i = 0; i < pTypeAttr->cImplTypes; i++ ) { hr = HB_VTBL( iTI )->GetImplTypeFlags( HB_THIS_( iTI ) i, &iFlags ); if( hr == S_OK && ( iFlags & IMPLTYPEFLAG_FDEFAULT ) && ( iFlags & IMPLTYPEFLAG_FSOURCE ) ) { if( HB_VTBL( iTI )->GetRefTypeOfImplType( HB_THIS_( iTI ) i, &hRefType ) == S_OK && HB_VTBL( iTI )->GetRefTypeInfo( HB_THIS_( iTI ) hRefType, &iTISink ) == S_OK ) { HB_TRACE( HB_TR_DEBUG, ( "_get_default_sink Method 2: default source is found" ) ); hr = HB_VTBL( iTISink )->GetTypeAttr( HB_THIS_( iTISink ) & pTypeAttr ); if( hr == S_OK ) { *piid = pTypeAttr->guid; HB_VTBL( iTISink )->ReleaseTypeAttr( HB_THIS_( iTISink ) pTypeAttr ); HB_VTBL( iTI )->ReleaseTypeAttr( HB_THIS_( iTI ) pTypeAttr ); HB_VTBL( iPCI )->Release( HB_THIS( iPCI ) ); return S_OK; } } } } HB_VTBL( iTI )->ReleaseTypeAttr( HB_THIS_( iTI ) pTypeAttr ); } } HB_VTBL( iPCI )->Release( HB_THIS( iPCI ) ); } else HB_TRACE( HB_TR_DEBUG, ( "_get_default_sink IProvideClassInfo obtain error %08lX", hr ) ); } /* Method 3: using CoClass */ hr = HB_VTBL( iDisp )->GetTypeInfo( HB_THIS_( iDisp ) 0, LOCALE_SYSTEM_DEFAULT, &iTI ); if( hr == S_OK ) { ITypeLib * iTL; TYPEATTR * pTypeAttr2; hr = HB_VTBL( iTI )->GetContainingTypeLib( HB_THIS_( iTI ) & iTL, NULL ); HB_VTBL( iTI )->Release( HB_THIS( iTI ) ); if( hr == S_OK ) { int iCount = HB_VTBL( iTL )->GetTypeInfoCount( HB_THIS( iTL ) ); for( i = 0; i < iCount; i++ ) { hr = HB_VTBL( iTL )->GetTypeInfo( HB_THIS_( iTL ) i, &iTI ); if( hr == S_OK ) { hr = HB_VTBL( iTI )->GetTypeAttr( HB_THIS_( iTI ) & pTypeAttr ); if( hr == S_OK ) { if( pTypeAttr->typekind == TKIND_COCLASS ) { for( j = 0; j < pTypeAttr->cImplTypes; j++ ) { if( szEvent ) { if( HB_VTBL( iTI )->GetRefTypeOfImplType( HB_THIS_( iTI ) j, &hRefType ) == S_OK && HB_VTBL( iTI )->GetRefTypeInfo( HB_THIS_( iTI ) hRefType, &iTISink ) == S_OK ) { BSTR bstr; hr = HB_VTBL( iTISink )->GetDocumentation( HB_THIS_( iTISink ) - 1, &bstr, NULL, NULL, NULL ); if( hr == S_OK ) { char str[ 256 ]; int iLen; iLen = WideCharToMultiByte( CP_ACP, 0, bstr, -1, str, sizeof( str ), NULL, NULL ); if( iLen > 0 ) { str[ iLen - 1 ] = '\0'; if( ! strcmp( szEvent, str ) ) { hr = HB_VTBL( iTISink )->GetTypeAttr( HB_THIS_( iTISink ) & pTypeAttr2 ); if( hr == S_OK ) { *piid = pTypeAttr2->guid; HB_VTBL( iTISink )->ReleaseTypeAttr( HB_THIS_( iTISink ) pTypeAttr2 ); HB_VTBL( iTISink )->Release( HB_THIS( iTISink ) ); HB_VTBL( iTI )->ReleaseTypeAttr( HB_THIS_( iTI ) pTypeAttr ); HB_VTBL( iTI )->Release( HB_THIS( iTI ) ); HB_VTBL( iTL )->Release( HB_THIS( iTL ) ); return S_OK; } } } } HB_VTBL( iTISink )->Release( HB_THIS( iTISink ) ); } } else /* szEvent == NULL */ { hr = HB_VTBL( iTI )->GetImplTypeFlags( HB_THIS_( iTI ) j, &iFlags ); if( hr == S_OK && ( iFlags & IMPLTYPEFLAG_FDEFAULT ) && ( iFlags & IMPLTYPEFLAG_FSOURCE ) ) { if( HB_VTBL( iTI )->GetRefTypeOfImplType( HB_THIS_( iTI ) j, &hRefType ) == S_OK && HB_VTBL( iTI )->GetRefTypeInfo( HB_THIS_( iTI ) hRefType, &iTISink ) == S_OK ) { hr = HB_VTBL( iTISink )->GetTypeAttr( HB_THIS_( iTISink ) & pTypeAttr2 ); if( hr == S_OK ) { #if 0 /* Debug code. You can also comment out iFlags condition, to list more interfaces [Mindaugas] */ BSTR bstr; char str[ 256 ]; int iLen; HB_VTBL( iTISink )->GetDocumentation( HB_THIS_( iTISink ) - 1, &bstr, NULL, NULL, NULL ); iLen = WideCharToMultiByte( CP_ACP, 0, bstr, -1, str, sizeof( str ), NULL, NULL ); str[ iLen - 1 ] = '\0'; HB_TRACE( HB_TR_DEBUG, ( "_get_default_sink Method 3: iFlags=%d guid=%s class=%s", iFlags, GUID2String( &( pTypeAttr2->guid ) ), str ) ); #endif *piid = pTypeAttr2->guid; HB_VTBL( iTISink )->ReleaseTypeAttr( HB_THIS_( iTISink ) pTypeAttr2 ); HB_VTBL( iTI )->ReleaseTypeAttr( HB_THIS_( iTI ) pTypeAttr ); HB_VTBL( iTI )->Release( HB_THIS( iTI ) ); HB_VTBL( iTL )->Release( HB_THIS( iTL ) ); return S_OK; } } } } } } HB_VTBL( iTI )->ReleaseTypeAttr( HB_THIS_( iTI ) pTypeAttr ); } HB_VTBL( iTI )->Release( HB_THIS( iTI ) ); } } HB_VTBL( iTL )->Release( HB_THIS( iTL ) ); } } return E_NOINTERFACE; }
static int hb_gt_std_ReadKey( PHB_GT pGT, int iEventMask ) { PHB_GTSTD pGTSTD; int ch = 0; HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_ReadKey(%p,%d)", pGT, iEventMask ) ); HB_SYMBOL_UNUSED( iEventMask ); pGTSTD = HB_GTSTD_GET( pGT ); #if defined( HB_HAS_TERMIOS ) { struct timeval tv; fd_set rfds; tv.tv_sec = 0; tv.tv_usec = 0; FD_ZERO( &rfds ); FD_SET( pGTSTD->hStdin, &rfds ); if( select( pGTSTD->hStdin + 1, &rfds, NULL, NULL, &tv ) > 0 ) { HB_BYTE bChar; if( hb_fsRead( pGTSTD->hStdin, &bChar, 1 ) == 1 ) ch = bChar; } } #elif defined( _MSC_VER ) && ! defined( HB_OS_WIN_CE ) if( pGTSTD->fStdinConsole ) { if( _kbhit() ) { ch = _getch(); if( ( ch == 0 || ch == 224 ) && _kbhit() ) { /* It was a function key lead-in code, so read the actual function key and then offset it by 256 */ ch = _getch() + 256; } ch = hb_gt_dos_keyCodeTranslate( ch ); } } else if( ! _eof( ( int ) pGTSTD->hStdin ) ) { HB_BYTE bChar; if( _read( ( int ) pGTSTD->hStdin, &bChar, 1 ) == 1 ) ch = bChar; } #elif defined( HB_OS_WIN ) if( ! pGTSTD->fStdinConsole ) { HB_BYTE bChar; if( hb_fsRead( pGTSTD->hStdin, &bChar, 1 ) == 1 ) ch = bChar; } else if( WaitForSingleObject( ( HANDLE ) hb_fsGetOsHandle( pGTSTD->hStdin ), 0 ) == WAIT_OBJECT_0 ) { #if defined( HB_OS_WIN_CE ) HB_BYTE bChar; if( hb_fsRead( pGTSTD->hStdin, &bChar, 1 ) == 1 ) ch = bChar; #else INPUT_RECORD ir; DWORD dwEvents; while( PeekConsoleInput( ( HANDLE ) hb_fsGetOsHandle( pGTSTD->hStdin ), &ir, 1, &dwEvents ) && dwEvents == 1 ) { if( ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown ) { HB_BYTE bChar; if( hb_fsRead( pGTSTD->hStdin, &bChar, 1 ) == 1 ) ch = bChar; } else /* Remove from the input queue */ ReadConsoleInput( ( HANDLE ) hb_fsGetOsHandle( pGTSTD->hStdin ), &ir, 1, &dwEvents ); } #endif } #elif defined( __WATCOMC__ ) if( pGTSTD->fStdinConsole ) { if( kbhit() ) { ch = getch(); if( ( ch == 0 || ch == 224 ) && kbhit() ) { /* It was a function key lead-in code, so read the actual function key and then offset it by 256 */ ch = getch() + 256; } ch = hb_gt_dos_keyCodeTranslate( ch ); } } else if( ! eof( pGTSTD->hStdin ) ) { HB_BYTE bChar; if( read( pGTSTD->hStdin, &bChar, 1 ) == 1 ) ch = bChar; } #else { if( ! pGTSTD->fStdinConsole ) { HB_BYTE bChar; if( hb_fsRead( pGTSTD->hStdin, &bChar, 1 ) == 1 ) ch = bChar; } else { int iTODO; /* TODO: */ } } #endif if( ch ) { int u = HB_GTSELF_KEYTRANS( pGT, ch ); if( u ) ch = HB_INKEY_NEW_UNICODE( u ); } return ch; }
void ct_setref (int iNewSwitch) { HB_TRACE(HB_TR_DEBUG, ("ct_setref(%i)",iNewSwitch)); siRefSwitch = iNewSwitch; return; }
static void hb_gt_std_Bell( PHB_GT pGT ) { HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Bell(%p)", pGT ) ); hb_gt_std_termOut( HB_GTSTD_GET( pGT ), s_szBell, 1 ); }
void ct_setatmupa (int iNewSwitch) { HB_TRACE(HB_TR_DEBUG, ("ct_setatmupa(%i)",iNewSwitch)); siAtMupaSwitch = iNewSwitch; return; }
static void hb_gt_std_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { int iColor; HB_BYTE bAttr; HB_USHORT usChar; int iLineFeed, iBackSpace, iMin; PHB_GTSTD pGTSTD; HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); iLineFeed = iBackSpace = 0; pGTSTD = HB_GTSTD_GET( pGT ); if( pGTSTD->iRow != iRow ) { iLineFeed = pGTSTD->iRow < iRow ? iRow - pGTSTD->iRow : 1; iCol = 0; iSize = pGTSTD->iWidth; } else if( pGTSTD->iCol < iCol ) { iSize += iCol - pGTSTD->iCol; iCol = pGTSTD->iCol; } else if( pGTSTD->iCol > iCol ) { if( pGTSTD->fStdoutConsole && pGTSTD->iCol <= pGTSTD->iWidth ) { iBackSpace = pGTSTD->iCol - iCol; if( iBackSpace > iSize ) iSize = iBackSpace; } else { iLineFeed = 1; iCol = 0; iSize = pGTSTD->iWidth; } } iMin = iLineFeed > 0 || pGTSTD->iLastCol <= iCol ? 0 : pGTSTD->iLastCol - iCol; while( iSize > iMin && HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iSize - 1, &iColor, &bAttr, &usChar ) ) { if( usChar != ' ' ) break; --iSize; } if( iSize > 0 ) { if( iLineFeed > 0 ) { /* * If you want to disable full screen redrawing in console (TTY) * output then comment out the 'if' block below, Druzus */ if( pGTSTD->fStdoutConsole ) { int i; if( pGTSTD->iRow > iRow ) { pGTSTD->iRow = -1; pGTSTD->fFullRedraw = HB_TRUE; } for( i = pGTSTD->iRow + 1; i < iRow; ++i ) hb_gt_std_DispLine( pGT, i, 0, -1 ); iLineFeed = 1; } do { hb_gt_std_newLine( pGTSTD ); } while( --iLineFeed ); pGTSTD->iLastCol = 0; } else if( iBackSpace > 0 ) { memset( pGTSTD->sLineBuf, HB_CHAR_BS, iBackSpace ); hb_gt_std_termOut( pGTSTD, pGTSTD->sLineBuf, iBackSpace ); } hb_gt_std_DispLine( pGT, iRow, iCol, iSize ); } }
void ct_setatlike (int iNewMode) { HB_TRACE(HB_TR_DEBUG, ("ct_setatlike(%i)",iNewMode)); siAtLikeMode = iNewMode; return; }
static const char * hb_nationGetMsg( int iMsg ) { HB_TRACE( HB_TR_DEBUG, ( "hb_nationGetMsg(%u)", iMsg ) ); return ( iMsg >= 1 && iMsg <= 13 ) ? hb_langDGetItem( HB_LANG_ITEM_BASE_NATMSG + iMsg - 1 ) : ""; }
void ct_setatlikechar (char cNewChar) { HB_TRACE(HB_TR_DEBUG, ("ct_setatlikechar(\'%c\')",cNewChar)); scAtLikeChar = cNewChar; return; }
void * hb_stackGetTSD( PHB_TSD pTSD ) { HB_STACK_TLS_PRELOAD HB_TRACE( HB_TR_DEBUG, ( "hb_stackGetTSD(%p)", pTSD ) ); #if defined( HB_MT_VM ) if( pTSD->iHandle == 0 || pTSD->iHandle > hb_stack.iTSD || hb_stack.pTSD[ pTSD->iHandle ].pTSD == NULL ) { if( pTSD->iHandle == 0 ) { hb_threadEnterCriticalSection( &TSD_counter ); /* repeated test protected by mutex to avoid race condition */ if( pTSD->iHandle == 0 ) pTSD->iHandle = ++s_iTSDCounter; hb_threadLeaveCriticalSection( &TSD_counter ); } if( pTSD->iHandle > hb_stack.iTSD ) { hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xrealloc( hb_stack.pTSD, ( pTSD->iHandle + 1 ) * sizeof( HB_TSD_HOLDER ) ); memset( &hb_stack.pTSD[ hb_stack.iTSD + 1 ], 0, ( pTSD->iHandle - hb_stack.iTSD ) * sizeof( HB_TSD_HOLDER ) ); hb_stack.iTSD = pTSD->iHandle; } #else if( pTSD->iHandle == 0 ) { HB_SIZE nSize = ( hb_stack.iTSD + 2 ) * sizeof( HB_TSD_HOLDER ); if( hb_stack.iTSD == 0 ) { hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xgrab( nSize ); memset( hb_stack.pTSD, 0, nSize ); } else { hb_stack.pTSD = ( PHB_TSD_HOLDER ) hb_xrealloc( hb_stack.pTSD, nSize ); } pTSD->iHandle = ++hb_stack.iTSD; #endif hb_stack.pTSD[ pTSD->iHandle ].pTSD = pTSD; hb_stack.pTSD[ pTSD->iHandle ].value = hb_xgrab( pTSD->iSize ); memset( hb_stack.pTSD[ pTSD->iHandle ].value, 0, pTSD->iSize ); if( pTSD->pInitFunc ) pTSD->pInitFunc( hb_stack.pTSD[ pTSD->iHandle ].value ); } return hb_stack.pTSD[ pTSD->iHandle ].value; } void * hb_stackTestTSD( PHB_TSD pTSD ) { HB_STACK_TLS_PRELOAD HB_TRACE( HB_TR_DEBUG, ( "hb_stackTestTSD(%p)", pTSD ) ); #if defined( HB_MT_VM ) return ( pTSD->iHandle && pTSD->iHandle <= hb_stack.iTSD ) ? hb_stack.pTSD[ pTSD->iHandle ].value : NULL; #else return pTSD->iHandle ? hb_stack.pTSD[ pTSD->iHandle ].value : NULL; #endif }
int ct_str_exit (void) { HB_TRACE(HB_TR_DEBUG, ("ctstr_exit()")); return(1); }
static unsigned char hb_gt_os2_GetCharHeight() { HB_TRACE( HB_TR_DEBUG, ( "hb_gt_os2_GetCharHeight()" ) ); return ( unsigned char ) ( s_vi.row ? ( s_vi.vres / s_vi.row ) - 1 : 0 ); }
static int hb_fsProcessExec( const char * pszFileName, HB_FHANDLE hStdin, HB_FHANDLE hStdout, HB_FHANDLE hStderr ) { int iResult = FS_ERROR; HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessExec(%s, %p, %p, %p)", pszFileName, ( void * ) ( HB_PTRDIFF ) hStdin, ( void * ) ( HB_PTRDIFF ) hStdout, ( void * ) ( HB_PTRDIFF ) hStderr ) ); #if defined( HB_OS_WIN_CE ) { LPTSTR lpAppName, lpParams; HB_BOOL fError; HB_SYMBOL_UNUSED( hStdin ); HB_SYMBOL_UNUSED( hStdout ); HB_SYMBOL_UNUSED( hStderr ); hb_getCommand( pszFileName, &lpAppName, &lpParams ); hb_vmUnlock(); fError = ! CreateProcess( lpAppName, /* lpAppName */ lpParams, /* lpCommandLine */ NULL, /* lpProcessAttr */ NULL, /* lpThreadAttr */ FALSE, /* bInheritHandles */ 0, /* dwCreationFlags */ NULL, /* lpEnvironment */ NULL, /* lpCurrentDirectory */ NULL, /* lpStartupInfo */ NULL ); /* lpProcessInformation */ hb_fsSetIOError( ! fError, 0 ); if( ! fError ) { hb_fsSetIOError( ! fError, 0 ); iResult = 0; } hb_vmLock(); if( lpAppName ) hb_xfree( lpAppName ); if( lpParams ) hb_xfree( lpParams ); } #elif defined( HB_OS_DOS ) || defined( HB_OS_WIN ) || defined( HB_OS_OS2 ) || \ defined( HB_OS_UNIX ) { int iStdIn, iStdOut, iStdErr; char ** argv; argv = hb_buildArgs( pszFileName ); hb_vmUnlock(); iStdIn = iStdOut = iStdErr = FS_ERROR; if( hStdin != FS_ERROR ) { iStdIn = dup( 0 ); dup2( hStdin, 0 ); } if( hStdout != FS_ERROR ) { iStdOut = dup( 1 ); dup2( hStdout, 1 ); } if( hStderr != FS_ERROR ) { iStdErr = dup( 2 ); dup2( hStderr, 2 ); } #if defined( HB_OS_UNIX ) && ! defined( HB_OS_VXWORKS ) && ! defined( HB_OS_SYMBIAN ) { pid_t pid = fork(); if( pid == 0 ) { /* close all non std* handles */ { int iMaxFD, i; iMaxFD = sysconf( _SC_OPEN_MAX ); if( iMaxFD < 3 ) iMaxFD = 1024; for( i = 3; i < iMaxFD; ++i ) hb_fsClose( i ); } /* reset extended process attributes */ ( void ) setuid( getuid() ); ( void ) setgid( getgid() ); /* execute command */ execvp( argv[ 0 ], argv ); exit( -1 ); } else if( pid != -1 ) { int iStatus; iResult = waitpid( pid, &iStatus, 0 ); #ifdef ERESTARTSYS if( iResult < 0 && errno != ERESTARTSYS ) #else if( iResult < 0 ) #endif iResult = -2; else if( iResult == 0 ) iResult = -1; else iResult = WIFEXITED( iStatus ) ? WEXITSTATUS( iStatus ) : 0; } } #elif defined( _MSC_VER ) || defined( __LCC__ ) || \ defined( __XCC__ ) || defined( __POCC__ ) iResult = _spawnvp( _P_WAIT, argv[ 0 ], argv ); #elif defined( __MINGW32__ ) || defined( __WATCOMC__ ) iResult = spawnvp( P_WAIT, argv[ 0 ], ( const char * const * ) argv ); #else iResult = spawnvp( P_WAIT, argv[ 0 ], ( char * const * ) argv ); #endif hb_fsSetIOError( iResult >= 0, 0 ); if( iStdIn != FS_ERROR ) { dup2( iStdIn, 0 ); close( iStdIn ); } if( iStdOut != FS_ERROR ) { dup2( iStdOut, 1 ); close( iStdOut ); } if( iStdErr != FS_ERROR ) { dup2( iStdErr, 2 ); close( iStdErr ); } hb_vmLock(); hb_freeArgs( argv ); } #else { int iTODO; /* TODO: for given platform */ HB_SYMBOL_UNUSED( pszFileName ); HB_SYMBOL_UNUSED( hStdin ); HB_SYMBOL_UNUSED( hStdout ); HB_SYMBOL_UNUSED( hStderr ); hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); } #endif return iResult; }
PHB_ITEM hb_libLoad( PHB_ITEM pLibName, PHB_ITEM pArgs ) { void * hDynLib = NULL; if( hb_itemGetCLen( pLibName ) > 0 ) { int argc = pArgs ? ( int ) hb_arrayLen( pArgs ) : 0, i; const char ** argv = NULL; if( argc > 0 ) { argv = ( const char ** ) hb_xgrab( sizeof( char * ) * argc ); for( i = 0; i < argc; ++i ) argv[ i ] = hb_arrayGetCPtr( pArgs, i + 1 ); } if( hb_vmLockModuleSymbols() ) { /* use stack address as first level marker */ hb_vmBeginSymbolGroup( ( void * ) hb_stackId(), HB_TRUE ); #if defined( HB_OS_WIN ) { void * hFileName; hDynLib = ( void * ) LoadLibrary( HB_ITEMGETSTR( pLibName, &hFileName, NULL ) ); hb_strfree( hFileName ); } #elif defined( HB_OS_OS2 ) { HB_UCHAR LoadError[ 256 ] = ""; /* Area for load failure information */ HMODULE hDynModule; if( DosLoadModule( ( PSZ ) LoadError, sizeof( LoadError ), ( PCSZ ) hb_itemGetCPtr( pLibName ), &hDynModule ) == NO_ERROR ) hDynLib = ( void * ) hDynModule; } #elif defined( HB_HAS_DLFCN ) hDynLib = ( void * ) dlopen( hb_itemGetCPtr( pLibName ), RTLD_LAZY | RTLD_GLOBAL ); if( ! hDynLib ) { HB_TRACE( HB_TR_DEBUG, ( "hb_libLoad(): dlopen(): %s", dlerror() ) ); } #else { int iTODO; } #endif /* set real marker */ hb_vmInitSymbolGroup( hDynLib, argc, argv ); hb_vmUnlockModuleSymbols(); } if( argv ) hb_xfree( ( void * ) argv ); } if( hDynLib ) { void ** pLibPtr = ( void ** ) hb_gcAllocate( sizeof( void * ), &s_gcDynlibFuncs ); *pLibPtr = hDynLib; return hb_itemPutPtrGC( NULL, pLibPtr ); } return NULL; }
int hb_fsProcessValue( HB_FHANDLE hProcess, HB_BOOL fWait ) { int iRetStatus = -1; HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessValue(%p, %d)", ( void * ) ( HB_PTRDIFF ) hProcess, fWait ) ); #if defined( HB_OS_WIN ) { HB_BOOL fError = HB_TRUE; DWORD dwResult; HANDLE hProc = ( HANDLE ) hb_fsGetOsHandle( hProcess ); if( hProc ) { hb_vmUnlock(); dwResult = WaitForSingleObject( hProc, fWait ? INFINITE : 0 ); if( dwResult == WAIT_OBJECT_0 ) { fError = ! GetExitCodeProcess( hProc, &dwResult ); iRetStatus = ! fError ? ( int ) dwResult : -2; } hb_fsSetIOError( ! fError, 0 ); if( ! fError ) CloseHandle( hProc ); hb_vmLock(); } else hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); } #elif defined( HB_OS_UNIX ) || ( defined( HB_OS_OS2 ) && defined( __GNUC__ ) ) { int iStatus; pid_t pid = ( pid_t ) hProcess; if( pid > 0 ) { hb_vmUnlock(); iRetStatus = waitpid( pid, &iStatus, fWait ? 0 : WNOHANG ); hb_fsSetIOError( iRetStatus >= 0, 0 ); #ifdef ERESTARTSYS if( iRetStatus < 0 && hb_fsOsError() != ( HB_ERRCODE ) ERESTARTSYS ) #else if( iRetStatus < 0 ) #endif iRetStatus = -2; else if( iRetStatus == 0 ) iRetStatus = -1; else iRetStatus = WIFEXITED( iStatus ) ? WEXITSTATUS( iStatus ) : 0; hb_vmLock(); } else hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); } #elif defined( HB_OS_OS2 ) { PID pid = ( PID ) hProcess; if( pid > 0 ) { RESULTCODES resultCodes = { 0, 0 }; APIRET ret; ret = DosWaitChild( DCWA_PROCESS, fWait ? DCWW_WAIT : DCWW_NOWAIT, &resultCodes, &pid, pid ); hb_fsSetIOError( ret == NO_ERROR, 0 ); if( ret == NO_ERROR ) iRetStatus = resultCodes.codeResult; else iRetStatus = -2; } else hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); } #elif defined( HB_OS_OS2 ) || defined( HB_OS_WIN ) { int iPid = ( int ) hProcess; HB_SYMBOL_UNUSED( fWait ); if( iPid > 0 ) { hb_vmUnlock(); #if defined( __BORLANDC__ ) iPid = cwait( &iRetStatus, iPid, 0 ); #else iPid = _cwait( &iRetStatus, iPid, 0 ); #endif hb_fsSetIOError( iPid > 0, 0 ); if( iPid != ( int ) hProcess ) iRetStatus = -1; hb_vmLock(); } else hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); } #else { int iTODO; /* TODO: for given platform */ HB_SYMBOL_UNUSED( hProcess ); HB_SYMBOL_UNUSED( fWait ); hb_fsSetError( ( HB_ERRCODE ) FS_ERROR ); } #endif return iRetStatus; }
const char * hb_dynsymName( PHB_DYNS pDynSym ) { HB_TRACE(HB_TR_DEBUG, ("hb_dynsymName(%p)", pDynSym)); return pDynSym->pSymbol->szName; }