bool CNCSJPCMainHeader::CloseEncoderFiles(bool bDelete) { bool bRet = true; if(m_pEncoderPLTFile) { char *pPLTFilename = bDelete ? NCSStrDup(CHAR_STRING(m_pEncoderPLTFile->GetName())) : NULL; bRet = m_pEncoderPLTFile->Close() == NCS_SUCCESS; if(bDelete && pPLTFilename) { NCSDeleteFile(pPLTFilename); NCSFree(pPLTFilename); } delete m_pEncoderPLTFile; m_pEncoderPLTFile = NULL; } if(m_pEncoderOffsetFile) { char *pPLTFilename = bDelete ? NCSStrDup(CHAR_STRING(m_pEncoderOffsetFile->GetName())) : NULL; bRet = m_pEncoderOffsetFile->Close() == NCS_SUCCESS; if(bDelete && pPLTFilename) { NCSDeleteFile(pPLTFilename); NCSFree(pPLTFilename); } delete m_pEncoderOffsetFile; m_pEncoderOffsetFile = NULL; } for(INT32 r = 0; r < (INT32)m_EncoderFiles.size(); r++) { char *pPLTFilename = bDelete ? NCSStrDup(CHAR_STRING(m_EncoderFiles[r]->GetName())) : NULL; bRet = m_EncoderFiles[r]->Close() == NCS_SUCCESS; if(bDelete && pPLTFilename) { NCSDeleteFile(pPLTFilename); NCSFree(pPLTFilename); } delete m_EncoderFiles[r]; m_EncoderFiles[r] = NULL; } m_EncoderFiles.clear(); return(bRet); }
static ptrdiff_t xfont_decode_coding_xlfd (char *xlfd, int len, char *output) { char *p0 = xlfd, *p1 = output; int c; while (*p0) { c = *(unsigned char *) p0++; p1 += CHAR_STRING (c, (unsigned char *) p1); if (--len == 0) break; } *p1 = 0; return (p1 - output); }
int doprnt (char *buffer, register int bufsize, const char *format, const char *format_end, va_list ap) { const char *fmt = format; /* Pointer into format string */ register char *bufptr = buffer; /* Pointer into output buffer.. */ /* Use this for sprintf unless we need something really big. */ char tembuf[DBL_MAX_10_EXP + 100]; /* Size of sprintf_buffer. */ unsigned size_allocated = sizeof (tembuf); /* Buffer to use for sprintf. Either tembuf or same as BIG_BUFFER. */ char *sprintf_buffer = tembuf; /* Buffer we have got with malloc. */ char *big_buffer = 0; register int tem; unsigned char *string; char fixed_buffer[20]; /* Default buffer for small formatting. */ char *fmtcpy; int minlen; unsigned char charbuf[MAX_MULTIBYTE_LENGTH + 1]; /* Used for %c. */ if (format_end == 0) format_end = format + strlen (format); if ((format_end - format + 1) < sizeof (fixed_buffer)) fmtcpy = fixed_buffer; else fmtcpy = (char *) alloca (format_end - format + 1); bufsize--; /* Loop until end of format string or buffer full. */ while (fmt != format_end && bufsize > 0) { if (*fmt == '%') /* Check for a '%' character */ { unsigned size_bound = 0; int width; /* Columns occupied by STRING. */ fmt++; /* Copy this one %-spec into fmtcpy. */ string = (unsigned char *) fmtcpy; *string++ = '%'; while (1) { *string++ = *fmt; if ('0' <= *fmt && *fmt <= '9') { /* Get an idea of how much space we might need. This might be a field width or a precision; e.g. %1.1000f and %1000.1f both might need 1000+ bytes. Parse the width or precision, checking for overflow. */ unsigned n = *fmt - '0'; while ('0' <= fmt[1] && fmt[1] <= '9') { if (n * 10 + fmt[1] - '0' < n) error ("Format width or precision too large"); n = n * 10 + fmt[1] - '0'; *string++ = *++fmt; } if (size_bound < n) size_bound = n; } else if (*fmt == '-' || *fmt == ' ' || *fmt == '.' || *fmt == '+') ; else break; fmt++; } *string = 0; /* Make the size bound large enough to handle floating point formats with large numbers. */ if (size_bound + DBL_MAX_10_EXP + 50 < size_bound) error ("Format width or precision too large"); size_bound += DBL_MAX_10_EXP + 50; /* Make sure we have that much. */ if (size_bound > size_allocated) { if (big_buffer) big_buffer = (char *) xrealloc (big_buffer, size_bound); else big_buffer = (char *) xmalloc (size_bound); sprintf_buffer = big_buffer; size_allocated = size_bound; } minlen = 0; switch (*fmt++) { default: error ("Invalid format operation %%%c", fmt[-1]); /* case 'b': */ case 'd': case 'o': case 'x': if (sizeof (int) == sizeof (EMACS_INT)) ; else if (sizeof (long) == sizeof (EMACS_INT)) /* Insert an `l' the right place. */ string[1] = string[0], string[0] = string[-1], string[-1] = 'l', string++; else abort (); sprintf (sprintf_buffer, fmtcpy, va_arg(ap, char *)); /* Now copy into final output, truncating as nec. */ string = (unsigned char *) sprintf_buffer; goto doit; case 'f': case 'e': case 'g': { double d = va_arg(ap, double); sprintf (sprintf_buffer, fmtcpy, d); /* Now copy into final output, truncating as nec. */ string = (unsigned char *) sprintf_buffer; goto doit; } case 'S': string[-1] = 's'; case 's': if (fmtcpy[1] != 's') minlen = atoi (&fmtcpy[1]); string = va_arg(ap, unsigned char *); tem = strlen (string); width = strwidth (string, tem); goto doit1; /* Copy string into final output, truncating if no room. */ doit: /* Coming here means STRING contains ASCII only. */ width = tem = strlen (string); doit1: /* We have already calculated: TEM -- length of STRING, WIDTH -- columns occupied by STRING when displayed, and MINLEN -- minimum columns of the output. */ if (minlen > 0) { while (minlen > width && bufsize > 0) { *bufptr++ = ' '; bufsize--; minlen--; } minlen = 0; } if (tem > bufsize) { /* Truncate the string at character boundary. */ tem = bufsize; while (!CHAR_HEAD_P (string[tem - 1])) tem--; memcpy (bufptr, string, tem); /* We must calculate WIDTH again. */ width = strwidth (bufptr, tem); } else memcpy (bufptr, string, tem); bufptr += tem; bufsize -= tem; if (minlen < 0) { while (minlen < - width && bufsize > 0) { *bufptr++ = ' '; bufsize--; minlen++; } minlen = 0; } continue; case 'c': { /* Sometimes for %c we pass a char, which would widen to int. Sometimes we pass XFASTINT() or XINT() values, which would be EMACS_INT. Let's hope that both are passed the same way, otherwise we'll need to rewrite callers. */ EMACS_INT chr = va_arg(ap, EMACS_INT); tem = CHAR_STRING ((int) chr, charbuf); string = charbuf; string[tem] = 0; width = strwidth (string, tem); if (fmtcpy[1] != 'c') minlen = atoi (&fmtcpy[1]); goto doit1; } case '%': fmt--; /* Drop thru and this % will be treated as normal */ } } { /* Just some character; Copy it if the whole multi-byte form fit in the buffer. */ char *save_bufptr = bufptr; do { *bufptr++ = *fmt++; } while (--bufsize > 0 && !CHAR_HEAD_P (*fmt)); if (!CHAR_HEAD_P (*fmt)) { bufptr = save_bufptr; break; } } };
ptrdiff_t doprnt (char *buffer, ptrdiff_t bufsize, const char *format, const char *format_end, va_list ap) { const char *fmt = format; /* Pointer into format string. */ char *bufptr = buffer; /* Pointer into output buffer. */ /* Use this for sprintf unless we need something really big. */ char tembuf[DBL_MAX_10_EXP + 100]; /* Size of sprintf_buffer. */ ptrdiff_t size_allocated = sizeof (tembuf); /* Buffer to use for sprintf. Either tembuf or same as BIG_BUFFER. */ char *sprintf_buffer = tembuf; /* Buffer we have got with malloc. */ char *big_buffer = NULL; enum text_quoting_style quoting_style = text_quoting_style (); ptrdiff_t tem = -1; char *string; char fixed_buffer[20]; /* Default buffer for small formatting. */ char *fmtcpy; int minlen; char charbuf[MAX_MULTIBYTE_LENGTH + 1]; /* Used for %c. */ USE_SAFE_ALLOCA; if (format_end == 0) format_end = format + strlen (format); fmtcpy = (format_end - format < sizeof (fixed_buffer) - 1 ? fixed_buffer : SAFE_ALLOCA (format_end - format + 1)); bufsize--; /* Loop until end of format string or buffer full. */ while (fmt < format_end && bufsize > 0) { char const *fmt0 = fmt; char fmtchar = *fmt++; if (fmtchar == '%') { ptrdiff_t size_bound = 0; ptrdiff_t width; /* Columns occupied by STRING on display. */ enum { pDlen = sizeof pD - 1, pIlen = sizeof pI - 1, pMlen = sizeof pMd - 2 }; enum { no_modifier, long_modifier, pD_modifier, pI_modifier, pM_modifier } length_modifier = no_modifier; static char const modifier_len[] = { 0, 1, pDlen, pIlen, pMlen }; int maxmlen = max (max (1, pDlen), max (pIlen, pMlen)); int mlen; /* Copy this one %-spec into fmtcpy. */ string = fmtcpy; *string++ = '%'; while (fmt < format_end) { *string++ = *fmt; if ('0' <= *fmt && *fmt <= '9') { /* Get an idea of how much space we might need. This might be a field width or a precision; e.g. %1.1000f and %1000.1f both might need 1000+ bytes. Parse the width or precision, checking for overflow. */ ptrdiff_t n = *fmt - '0'; while (fmt + 1 < format_end && '0' <= fmt[1] && fmt[1] <= '9') { /* Avoid ptrdiff_t, size_t, and int overflow, as many sprintfs mishandle widths greater than INT_MAX. This test is simple but slightly conservative: e.g., (INT_MAX - INT_MAX % 10) is reported as an overflow even when it's not. */ if (n >= min (INT_MAX, min (PTRDIFF_MAX, SIZE_MAX)) / 10) error ("Format width or precision too large"); n = n * 10 + fmt[1] - '0'; *string++ = *++fmt; } if (size_bound < n) size_bound = n; } else if (! (*fmt == '-' || *fmt == ' ' || *fmt == '.' || *fmt == '+')) break; fmt++; } /* Check for the length modifiers in textual length order, so that longer modifiers override shorter ones. */ for (mlen = 1; mlen <= maxmlen; mlen++) { if (format_end - fmt < mlen) break; if (mlen == 1 && *fmt == 'l') length_modifier = long_modifier; if (mlen == pDlen && memcmp (fmt, pD, pDlen) == 0) length_modifier = pD_modifier; if (mlen == pIlen && memcmp (fmt, pI, pIlen) == 0) length_modifier = pI_modifier; if (mlen == pMlen && memcmp (fmt, pMd, pMlen) == 0) length_modifier = pM_modifier; } mlen = modifier_len[length_modifier]; memcpy (string, fmt + 1, mlen); string += mlen; fmt += mlen; *string = 0; /* Make the size bound large enough to handle floating point formats with large numbers. */ if (size_bound > min (PTRDIFF_MAX, SIZE_MAX) - DBL_MAX_10_EXP - 50) error ("Format width or precision too large"); size_bound += DBL_MAX_10_EXP + 50; /* Make sure we have that much. */ if (size_bound > size_allocated) { if (big_buffer) xfree (big_buffer); big_buffer = xmalloc (size_bound); sprintf_buffer = big_buffer; size_allocated = size_bound; } minlen = 0; switch (*fmt++) { default: error ("Invalid format operation %s", fmtcpy); /* case 'b': */ case 'l': case 'd': switch (length_modifier) { case no_modifier: { int v = va_arg (ap, int); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; case long_modifier: { long v = va_arg (ap, long); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; case pD_modifier: signed_pD_modifier: { ptrdiff_t v = va_arg (ap, ptrdiff_t); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; case pI_modifier: { EMACS_INT v = va_arg (ap, EMACS_INT); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; case pM_modifier: { intmax_t v = va_arg (ap, intmax_t); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; } /* Now copy into final output, truncating as necessary. */ string = sprintf_buffer; goto doit; case 'o': case 'x': switch (length_modifier) { case no_modifier: { unsigned v = va_arg (ap, unsigned); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; case long_modifier: { unsigned long v = va_arg (ap, unsigned long); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; case pD_modifier: goto signed_pD_modifier; case pI_modifier: { EMACS_UINT v = va_arg (ap, EMACS_UINT); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; case pM_modifier: { uintmax_t v = va_arg (ap, uintmax_t); tem = sprintf (sprintf_buffer, fmtcpy, v); } break; } /* Now copy into final output, truncating as necessary. */ string = sprintf_buffer; goto doit; case 'f': case 'e': case 'g': { double d = va_arg (ap, double); tem = sprintf (sprintf_buffer, fmtcpy, d); /* Now copy into final output, truncating as necessary. */ string = sprintf_buffer; goto doit; } case 'S': string[-1] = 's'; case 's': if (fmtcpy[1] != 's') minlen = atoi (&fmtcpy[1]); string = va_arg (ap, char *); tem = strlen (string); if (STRING_BYTES_BOUND < tem) error ("String for %%s or %%S format is too long"); width = strwidth (string, tem); goto doit1; /* Copy string into final output, truncating if no room. */ doit: eassert (0 <= tem); /* Coming here means STRING contains ASCII only. */ if (STRING_BYTES_BOUND < tem) error ("Format width or precision too large"); width = tem; doit1: /* We have already calculated: TEM -- length of STRING, WIDTH -- columns occupied by STRING when displayed, and MINLEN -- minimum columns of the output. */ if (minlen > 0) { while (minlen > width && bufsize > 0) { *bufptr++ = ' '; bufsize--; minlen--; } minlen = 0; } if (tem > bufsize) { /* Truncate the string at character boundary. */ tem = bufsize; do { tem--; if (CHAR_HEAD_P (string[tem])) { if (BYTES_BY_CHAR_HEAD (string[tem]) <= bufsize - tem) tem = bufsize; break; } } while (tem != 0); memcpy (bufptr, string, tem); bufptr[tem] = 0; /* Trigger exit from the loop, but make sure we return to the caller a value which will indicate that the buffer was too small. */ bufptr += bufsize; bufsize = 0; continue; } memcpy (bufptr, string, tem); bufptr += tem; bufsize -= tem; if (minlen < 0) { while (minlen < - width && bufsize > 0) { *bufptr++ = ' '; bufsize--; minlen++; } minlen = 0; } continue; case 'c': { int chr = va_arg (ap, int); tem = CHAR_STRING (chr, (unsigned char *) charbuf); string = charbuf; string[tem] = 0; width = strwidth (string, tem); if (fmtcpy[1] != 'c') minlen = atoi (&fmtcpy[1]); goto doit1; } case '%': fmt--; /* Drop thru and this % will be treated as normal */ } } char const *src; ptrdiff_t srclen; if (quoting_style == CURVE_QUOTING_STYLE && fmtchar == '`') src = uLSQM, srclen = sizeof uLSQM - 1; else if (quoting_style == CURVE_QUOTING_STYLE && fmtchar == '\'') src = uRSQM, srclen = sizeof uRSQM - 1; else if (quoting_style == STRAIGHT_QUOTING_STYLE && fmtchar == '`') src = "'", srclen = 1; else { while (fmt < format_end && !CHAR_HEAD_P (*fmt)) fmt++; src = fmt0, srclen = fmt - fmt0; } if (bufsize < srclen) { /* Truncate, but return value that will signal to caller that the buffer was too small. */ do *bufptr++ = '\0'; while (--bufsize != 0); } else { do *bufptr++ = *src++; while (--srclen != 0); } }
/* ** Get a temporary file name ** ** Can pass in Dir to use instead of %TEMP% ** Can pass in prefix to use instead of NCS ** Can pass in file extension to use instead of .tmp */ char *NCSGetTempFileName(char *pDir, char *pPrefix, char *pExt) { char *pTmpName = NULL; #if defined PALM return(NULL); #else /* MACINTOSH */ char buf[MAX_PATH]; if(pDir == (char *)NULL || (pDir && strlen(pDir) == 0)) { pDir = NCSGetTempDirectory(); } else { pDir = NCSStrDup(pDir); } if(pExt == NULL) { pExt = ".tmp"; } if(pPrefix == NULL) { pPrefix = "NCS"; } #ifdef WIN32 { int i = 0; #ifndef _WIN32_WCE srand( (unsigned)time( NULL ) ); #endif while(i < 65535) { sprintf(buf, "%s\\%s%lx%lx%s", pDir, pPrefix, rand(), rand(), pExt); #if defined(_WIN32_WCE)||defined(NCS_MINDEP_BUILD) if(NCSFileSizeBytes(buf) < 0) { #else if(PathFileExistsA(buf) == FALSE) { #endif pTmpName = NCSStrDup(buf); break; } i++; } } NCSFree((void*)pDir); #elif defined( MACOSX ) sprintf(buf, "%sXXXXXX", pPrefix ? pPrefix : "NCS"); pTmpName = NCSMalloc(strlen(pDir) + strlen(buf) + strlen(pExt) + 3, FALSE); sprintf(pTmpName, "%s/%s", pDir, buf); mktemp(pTmpName); NCSFree((void*)pDir); strcat(pTmpName, pExt); // FIXME: Is this really going to be unique? #else sprintf(buf, "%sXXXXXX", pPrefix ? pPrefix : "NCS"); pTmpName = NCSMalloc(strlen(pDir) + strlen(buf) + strlen(pExt) + 3, FALSE); sprintf(pTmpName, "%s/%s", pDir, buf); mktemp(pTmpName); NCSFree((void*)pDir); strcat(pTmpName, pExt); // FIXME: Is this really going to be unique? #endif #endif return(pTmpName); } /* ** Get name of temp directory ** ** WIN32: ** Default: %TEMP% env variable ** 9x: C:\Windows\Temp ** NT: C:\Temp ** CE: \Temp */ char *NCSGetTempDirectory(void) { #ifdef _WIN32_WCE return(NCSStrDup("\\Temp")); #elif defined WIN32 NCSTChar winbuf[MAX_PATH]; if(GetTempPath((DWORD)MAX_PATH, winbuf) == 0) { if(GetSystemDirectory(winbuf, MAX_PATH)) { if(NCSGetPlatform() == NCS_WINDOWS_NT) { /* eg, c:\Temp */ winbuf[3] = '\0'; NCSTCat(winbuf, NCS_T("Temp")); } else { /* eg, c:\Windows\Temp */ NCSTCat(winbuf, NCS_T("Temp")); } } } if((winbuf[0] != '\0') && (winbuf[NCSTLen(winbuf) - 1] == '\\')) { winbuf[NCSTLen(winbuf) - 1] = '\0'; } return(NCSStrDup(CHAR_STRING(winbuf))); #elif defined PALM return(NCSStrDup("")); #elif defined MACOSX FSRef tempRef; UInt8 szPath[1024] = ""; if( FSFindFolder( kUserDomain, kTemporaryFolderType, kDontCreateFolder, &tempRef ) == noErr ) { if( FSRefMakePath( &tempRef, szPath, 1024 ) == noErr ) { } } return( NCSStrDup(szPath) ); #elif defined POSIX return(NCSStrDup("/tmp")); #else /* PALM */ char *szTmpDir = getenv("TMP"); if (szTmpDir != NULL) return NCSStrDup(szTmpDir); else return NCSStrDup("/tmp"); #endif } /* ** Get File Version information [01] ** */ BOOLEAN NCSFileGetVersion(char *pFileName, UINT16 *pMajor, UINT16 *pMinor, UINT16 *pRevision, UINT16 *pBuild) { BOOLEAN bRVal = FALSE; if(pFileName) { #if defined(_WIN32_WCE)||defined(NCS_MINDEP_BUILD) return(FALSE); #elif defined WIN32 DWORD dwVISize; DWORD dwZero; dwVISize = GetFileVersionInfoSize(OS_STRING(pFileName), &dwZero); if(dwVISize != 0) { LPVOID lpData = NCSMalloc(dwVISize, TRUE); if(lpData) { if(GetFileVersionInfo(OS_STRING(pFileName), 0, dwVISize, lpData)) { VS_FIXEDFILEINFO *pVI = (VS_FIXEDFILEINFO*)NULL; UINT dwSize; if(VerQueryValue(lpData, NCS_T("\\"), (LPVOID*)&pVI, &dwSize) && pVI) { if(pMajor) { *pMajor = (UINT16)(pVI->dwFileVersionMS >> 16); } if(pMinor) { *pMinor = (UINT16)(pVI->dwFileVersionMS & 0xffff); } if(pRevision) { *pRevision = (UINT16)(pVI->dwFileVersionLS >> 16); } if(pBuild) { *pBuild = (UINT16)(pVI->dwFileVersionLS & 0xffff); } bRVal = TRUE; } } NCSFree(lpData); } }
/* ** Get the size of the given file */ INT64 NCSFileSizeBytes(NCSTChar *pFilename) { #ifdef WIN32 #ifdef _WIN32_WCE DWORD dwLow; DWORD dwHigh; HANDLE hFile; if(hFile = CreateFile(pFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL)) { dwLow = GetFileSize(hFile, &dwHigh); if(dwLow == 0xffffffff && GetLastError() != NO_ERROR) { CloseHandle(hFile); return(-1); } else { CloseHandle(hFile); return((UINT64)dwLow | ((UINT64)dwHigh << 32)); } } else { return(-1); } #else /* _WIN32_WCE */ struct _stati64 statbuf; #ifdef NCS_BUILD_UNICODE #define _tstati64 _wstati64 #else #define _tstati64 _stati64 #endif if(_tstati64(pFilename, &statbuf) != 0) { DWORD dwLow; DWORD dwHigh; HANDLE hFile; #ifdef NCS_BUILD_UNICODE if(hFile = CreateFileW(pFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL)) { #else if(hFile = CreateFileA(pFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL)) { #endif dwLow = GetFileSize(hFile, &dwHigh); if(dwLow == 0xffffffff && GetLastError() != NO_ERROR) { CloseHandle(hFile); return(-1); } else { CloseHandle(hFile); return((UINT64)dwLow | ((UINT64)dwHigh << 32)); } } else { return(-1); } } return((INT64)statbuf.st_size); #undef _tstati64 #endif #elif defined POSIX #ifdef _LARGEFILE64_SOURCE struct stat64 statbuf; if (stat64(CHAR_STRING(pFilename), &statbuf) != 0) { return(-1); } return((INT64)statbuf.st_size); #else struct stat statbuf; if (stat(CHAR_STRING(pFilename), &statbuf) != 0) { return(-1); } return((INT64)statbuf.st_size); #endif #elif defined IRIX struct stat64 statbuf; if (stat(CHAR_STRING(pFilename), &statbuf) != 0) { return(-1); } return((INT64)statbuf.st_size); #elif defined PALM NCS_FILE_HANDLE hFile; if(NCSFileOpen(pFilename, NCS_FILE_READ, &hFile) == NCS_SUCCESS) { INT32 nFileSize = hFile->nDBSize; NCSFileClose(hFile); return((INT64)nFileSize); } return(-1); #else /* WIN32 */ #error NCSFileSizeBytes(); #endif /* WIN32 */ } /* ** Get the size of the given file */ INT64 NCSFreeDiskSpaceBytes(char *pDirName, INT64 *pTotal) { #ifdef WIN32 NCS_FUNCADDR pGetDiskFreeSpaceEx; //WINBASEAPI BOOL (WINAPI *pGetDiskFreeSpaceEx)(LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER); char szPath[MAX_PATH]; strcpy(szPath, pDirName); if(szPath[0] == '\\' && szPath[strlen(szPath) - 1] != '\\') { // UNC dir must have trailing backslash strcat(szPath, "\\"); } pGetDiskFreeSpaceEx = (NCS_FUNCADDR)GetProcAddress( GetModuleHandle(NCS_T("kernel32.dll")), "GetDiskFreeSpaceExA"); if(pGetDiskFreeSpaceEx) { ULARGE_INTEGER i64FreeBytesToCaller; ULARGE_INTEGER i64TotalBytes; ULARGE_INTEGER i64FreeBytes; if(((BOOL (WINAPI *)(LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER))pGetDiskFreeSpaceEx)(szPath, (PULARGE_INTEGER)&i64FreeBytesToCaller, (PULARGE_INTEGER)&i64TotalBytes, (PULARGE_INTEGER)&i64FreeBytes)) { if(pTotal) { *pTotal = (INT64)i64TotalBytes.QuadPart; } return((INT64)i64FreeBytesToCaller.QuadPart); } else { return(-1); } } else { #if !defined(_WIN32_WCE) DWORD dwSectPerClust; DWORD dwBytesPerSect; DWORD dwFreeClusters; DWORD dwTotalClusters; if(GetDiskFreeSpace(OS_STRING(szPath), &dwSectPerClust, &dwBytesPerSect, &dwFreeClusters, &dwTotalClusters)) { if(pTotal) { *pTotal = (INT64)dwBytesPerSect * (INT64)dwSectPerClust * (INT64)dwTotalClusters; } return((INT64)dwBytesPerSect * (INT64)dwSectPerClust * (INT64)dwFreeClusters); } else { return(-1); } #elif defined(_WIN32_WCE) ULARGE_INTEGER nFreeBytesToCaller; ULARGE_INTEGER nTotalBytes; ULARGE_INTEGER nTotalFreeBytes; if (GetDiskFreeSpaceEx(OS_STRING(szPath), &nFreeBytesToCaller, &nTotalBytes, &nTotalFreeBytes)) { if(pTotal) { *pTotal = (INT64) nFreeBytesToCaller.QuadPart; } return((INT64)nFreeBytesToCaller.QuadPart); } else { return (-1); } #endif } #else // WIN32 return(-1); #endif }
NCSError NCSFileOpen(const NCSTChar *szFilename, int iFlags, NCS_FILE_HANDLE *phFile) { #ifdef WIN32 DWORD dwMode = GENERIC_READ; DWORD dwCreate = OPEN_EXISTING; if(iFlags & NCS_FILE_READ) dwMode = GENERIC_READ; if(iFlags & NCS_FILE_READ_WRITE) dwMode = GENERIC_READ|GENERIC_WRITE; if(iFlags & NCS_FILE_CREATE) dwCreate = CREATE_ALWAYS; if(iFlags & NCS_FILE_CREATE_UNIQUE) dwCreate = CREATE_NEW; if(iFlags & NCS_FILE_APPEND) dwCreate = OPEN_ALWAYS; *phFile = CreateFile(szFilename, // file name dwMode, // Generic read mode FILE_SHARE_READ, // Let anyone access and share the file NULL, // No security info (so can't be inherited by child process) dwCreate, // File must exist to be opened FILE_FLAG_RANDOM_ACCESS, // Going to be doing lots of random access NULL); // And no template file for attributes if( *phFile == INVALID_HANDLE_VALUE ) { return( NCS_FILE_OPEN_FAILED ); } else { return( NCS_SUCCESS ); } #elif defined MACINTOSH #if __POWERPC__ int i,length, result; Str255 pascalString; FSSpec fileSpec; // We have a C string, we need a PASCAL string. length = strlen(szFilename) + 1; for(i = 1; i < length; ++i) pascalString[i] = szFilename[i - 1]; pascalString[0] = strlen(szFilename); // Create a File Specification Record, then create a File result = FSMakeFSSpec(0,0,pascalString,&fileSpec); // return is meaningless, since the only possible error doesn't effect processing in this case switch(result) { case noErr: // we could dRes pFile here, but we are the only user result =FSpOpenDF(&fileSpec, fsRdPerm, (short *)phFile); if(result) return NCS_FILE_OPEN_FAILED; else return NCS_SUCCESS; break; default: return NCS_SUCCESS; break; } #else /* __POWERPC__ */ int i,length, result; Str255 pascalString; // We have a C string, we need a PASCAL string. length = strlen(szFilename) + 1; for(i = 1; i < length; ++i) pascalString[i] = szFilename[i - 1]; pascalString[0] = strlen(szFilename); result =FSOpen(pascalString, 0, (short *)phFile); if(result) return TRUE; else return FALSE; #endif /* __POWERPC__ */ #elif defined PALM NCS_FILE_HANDLE hFile; Err eErr; UInt32 nMode = 0; if(hFile = (NCS_FILE_HANDLE)NCSMalloc(sizeof(NCS_FILE_HANDLE_STRUCT), TRUE)) { hFile->dbID = DmFindDatabase(0, szFilename); if(hFile->dbID) { Char nameP[dmDBNameLength]; UInt16 attributes; UInt16 version; UInt32 crDate; UInt32 modDate; UInt32 bckUpDate; UInt32 modNum; LocalID appInfoID; LocalID sortInfoID; UInt32 type; UInt32 creator; DmDatabaseInfo(0, hFile->dbID, nameP, &attributes, &version, &crDate, &modDate, &bckUpDate, &modNum, &appInfoID, &sortInfoID, &type, &creator); if(creator == NCS_PALM_CREATOR_ID) { if(hFile->dbRef = DmOpenDatabase(0, hFile->dbID, dmModeReadOnly|dmModeShowSecret)) { UInt32 nRecords; UInt32 nTotalBytes; UInt32 nDataBytes; eErr = DmDatabaseSize(0, hFile->dbID, &nRecords, &nTotalBytes, &nDataBytes); if(eErr == errNone) { MemHandle hRecord; hFile->nRecords = nRecords; hFile->nDBSize = nDataBytes; #ifdef NOTDEF if(hRecord = DmGetRecord(hFile->dbRef, 0)) { MemPtr pData; if(pData = MemHandleLock(hRecord)) { hFile->nRecordSize = ((UINT16*)pData)[0]; MemHandleUnlock(hRecord); } DmReleaseRecord(hFile->dbRef, 0, false); } #endif *phFile = hFile; return(NCS_SUCCESS); } DmCloseDatabase(hFile->dbRef); return(NCSPalmGetNCSError(eErr)); } } } } else { return(NCS_COULDNT_ALLOC_MEMORY); } /* if(iFlags & NCS_FILE_READ) nMode = fileModeReadOnly|fileModeAnyTypeCreator; if(iFlags & NCS_FILE_READ_WRITE) nMode = fileModeUpdate|fileModeAnyTypeCreator; if(iFlags & NCS_FILE_CREATE) nMode = fileModeReadWrite|fileModeAnyTypeCreator; if(iFlags & NCS_FILE_CREATE_UNIQUE) nMode = fileModeReadWrite|fileModeDontOverwrite|fileModeAnyTypeCreator; if(iFlags & NCS_FILE_APPEND) nMode = fileModeAppend|fileModeAnyTypeCreator; *phFile = FileOpen(0, (char*)szFilename, 0, 0, nMode, &eErr); return(NCSPalmGetNCSError(eErr)); */ #elif defined(POSIX) int flags = O_RDONLY; if(iFlags & NCS_FILE_READ) flags = O_RDONLY; if(iFlags & NCS_FILE_READ_WRITE) flags = O_RDWR; if(iFlags & NCS_FILE_CREATE) flags |= O_CREAT; if(iFlags & NCS_FILE_CREATE_UNIQUE) flags |= O_CREAT|O_EXCL; if(iFlags & NCS_FILE_APPEND) flags |= O_APPEND; #if defined SOLARIS || (defined(HPUX) && !defined(__LP64__)) // Enable 64bit! flags |= O_LARGEFILE; #endif #ifdef HPUX *phFile = open64((const char*)CHAR_STRING(szFilename), (int)flags); #ifdef NOTDEF if (*phFile < 0) { fprintf(stderr, "Error opening file : %ld\n", errno); if (errno == EOVERFLOW) { fprintf(stderr, "The named file is a regular file and the size " "of the file cannot be represented correctly in an object of " "size off_t."); } } #endif #else *phFile = open((const char*)CHAR_STRING(szFilename), (int)flags, S_IRUSR|S_IWUSR); #endif if(*phFile != -1) { return(NCS_SUCCESS); } else { return(NCS_FILE_OPEN_FAILED); } #else /* SOLARIS||IRIX */ #error ERROR EcwFileCreate() routine is not defined for this platform #endif /* WIN32 */ }
static Lisp_Object casify_object (enum case_action flag, Lisp_Object obj) { register int c, c1; register int inword = flag == CASE_DOWN; /* If the case table is flagged as modified, rescan it. */ if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1])) Fset_case_table (BVAR (current_buffer, downcase_table)); if (INTEGERP (obj)) { int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META); int flags = XINT (obj) & flagbits; int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters)); /* If the character has higher bits set above the flags, return it unchanged. It is not a real character. */ if ((unsigned) XFASTINT (obj) > (unsigned) flagbits) return obj; c1 = XFASTINT (obj) & ~flagbits; /* FIXME: Even if enable-multibyte-characters is nil, we may manipulate multibyte chars. This means we have a bug for latin-1 chars since when we receive an int 128-255 we can't tell whether it's an eight-bit byte or a latin-1 char. */ if (c1 >= 256) multibyte = 1; if (! multibyte) MAKE_CHAR_MULTIBYTE (c1); c = downcase (c1); if (inword) XSETFASTINT (obj, c | flags); else if (c == (XFASTINT (obj) & ~flagbits)) { if (! inword) c = upcase1 (c1); if (! multibyte) MAKE_CHAR_UNIBYTE (c); XSETFASTINT (obj, c | flags); } return obj; } if (!STRINGP (obj)) wrong_type_argument (Qchar_or_string_p, obj); else if (!STRING_MULTIBYTE (obj)) { EMACS_INT i; EMACS_INT size = SCHARS (obj); obj = Fcopy_sequence (obj); for (i = 0; i < size; i++) { c = SREF (obj, i); MAKE_CHAR_MULTIBYTE (c); c1 = c; if (inword && flag != CASE_CAPITALIZE_UP) c = downcase (c); else if (!uppercasep (c) && (!inword || flag != CASE_CAPITALIZE_UP)) c = upcase1 (c1); if ((int) flag >= (int) CASE_CAPITALIZE) inword = (SYNTAX (c) == Sword); if (c != c1) { MAKE_CHAR_UNIBYTE (c); /* If the char can't be converted to a valid byte, just don't change it. */ if (c >= 0 && c < 256) SSET (obj, i, c); } } return obj; } else { EMACS_INT i, i_byte, size = SCHARS (obj); int len; USE_SAFE_ALLOCA; unsigned char *dst, *o; /* Over-allocate by 12%: this is a minor overhead, but should be sufficient in 99.999% of the cases to avoid a reallocation. */ EMACS_INT o_size = SBYTES (obj) + SBYTES (obj) / 8 + MAX_MULTIBYTE_LENGTH; SAFE_ALLOCA (dst, void *, o_size); o = dst; for (i = i_byte = 0; i < size; i++, i_byte += len) { if ((o - dst) + MAX_MULTIBYTE_LENGTH > o_size) { /* Not enough space for the next char: grow the destination. */ unsigned char *old_dst = dst; o_size += o_size; /* Probably overkill, but extremely rare. */ SAFE_ALLOCA (dst, void *, o_size); memcpy (dst, old_dst, o - old_dst); o = dst + (o - old_dst); } c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len); if (inword && flag != CASE_CAPITALIZE_UP) c = downcase (c); else if (!uppercasep (c) && (!inword || flag != CASE_CAPITALIZE_UP)) c = upcase1 (c); if ((int) flag >= (int) CASE_CAPITALIZE) inword = (SYNTAX (c) == Sword); o += CHAR_STRING (c, o); } eassert (o - dst <= o_size); obj = make_multibyte_string ((char *) dst, size, o - dst); SAFE_FREE (); return obj; } }