int GetFileMode(char *name)
{
DWORD dwAttr;
#if defined(__RSXNT__) /* RSXNT/EMX C rtl uses OEM charset */
char *ansi_name = (char *)alloca(strlen(name) + 1);
OemToAnsi(name, ansi_name);
name = ansi_name;
#endif
dwAttr = GetFileAttributes(name);
if ( dwAttr == 0xFFFFFFFF ) {
zipwarn("reading file attributes failed: ", name);
/*
fprintf(mesg, "zip diagnostic: GetFileAttributes failed");
fflush();
*/
return(0x20); /* the most likely, though why the error? security? */
}
return(
(dwAttr&FILE_ATTRIBUTE_READONLY ? A_RONLY :0)
| (dwAttr&FILE_ATTRIBUTE_HIDDEN ? A_HIDDEN :0)
| (dwAttr&FILE_ATTRIBUTE_SYSTEM ? A_SYSTEM :0)
| (dwAttr&FILE_ATTRIBUTE_DIRECTORY ? A_DIR :0)
| (dwAttr&FILE_ATTRIBUTE_ARCHIVE ? A_ARCHIVE :0));
}
local int FSusesLocalTime(const char *path)
{
char *tmp0;
char rootPathName[4];
char tmp1[MAX_PATH], tmp2[MAX_PATH];
DWORD volSerNo, maxCompLen, fileSysFlags;
#if defined(__RSXNT__) /* RSXNT/EMX C rtl uses OEM charset */
char *ansi_path = (char *)alloca(strlen(path) + 1);
OemToAnsi(path, ansi_path);
path = ansi_path;
#endif
if (isalpha((uch)path[0]) && (path[1] == ':'))
tmp0 = (char *)path;
else
{
GetFullPathName(path, MAX_PATH, tmp1, &tmp0);
tmp0 = &tmp1[0];
}
strncpy(rootPathName, tmp0, 3); /* Build the root path name, */
rootPathName[3] = '\0'; /* e.g. "A:/" */
GetVolumeInformation((LPCTSTR)rootPathName, (LPTSTR)tmp1, (DWORD)MAX_PATH,
&volSerNo, &maxCompLen, &fileSysFlags,
(LPTSTR)tmp2, (DWORD)MAX_PATH);
/* Volumes in (V)FAT and (OS/2) HPFS format store file timestamps in
* local time!
*/
return !strncmp(strupr(tmp2), "FAT", 3) ||
!strncmp(tmp2, "VFAT", 4) ||
!strncmp(tmp2, "HPFS", 4);
} /* end function FSusesLocalTime() */
// display a line to the user. Assumes line doesn't end with a newline.
VOID FAR DisplayLine(CHAR * szOutput)
{
if (hFileOutput)
{
#ifndef MAC
// convert szOutput in-place to OEM char set
AnsiToOem(szOutput, szOutput);
#endif // !MAC
fputs(szOutput, hFileOutput);
fputs("\n", hFileOutput);
#ifndef MAC
// convert back to ANSI in case the caller reuses this string
OemToAnsi(szOutput, szOutput);
#endif // !MAC
}
else
{
#ifdef NO_MPW
MacMessageBox(szOutput);
#else //NO_MPW
#ifndef WIN16
#ifndef MAC
// convert szOutput in-place to OEM char set
AnsiToOem(szOutput, szOutput);
#endif // !MAC
printf("%s\n", szOutput);
#ifndef MAC
// convert back to ANSI in case the caller reuses this string
OemToAnsi(szOutput, szOutput);
#endif // !MAC
#else //!WIN16
// poor man's output under Windows
MessageBox(NULL, szOutput, szAppTitle, MB_OK);
#endif //!WIN16
#endif //NO_MPW
}
}
//---------------------------------------------------------------------------
// SetHelpFileName
//
// This function is called on startup and creates a fully qualified path to
// the help file.
// 1. trys current working dir of app
// 2. trys where module running from
// 3. trys windows OpenFile search rules
//
// CHANGES:
// szHelpFileName : full path or empty string if not found
// RETURNS: Nothing
//---------------------------------------------------------------------------
VOID SetHelpFileName (VOID)
{
INT len; /* length of string */
OFSTRUCT of; /* OpenFile structure */
HFILE fh; /* file handle */
/* brings in malloc code unnecessarily */
_getcwd(szHelpFileName,sizeof(szHelpFileName));
strcat(szHelpFileName,"\\");
strcat(szHelpFileName,szHelp);
if (MOpenFile(szHelpFileName, &of, OF_EXIST) != -1)
return;
len = GetModuleFileName (GetModuleHandle ("TESTDRVR"),
szHelpFileName, sizeof(szHelpFileName));
if (len > 0)
{
/* don't use basename of this, as maybe the exe has been
** renamed. Can't look under new name, as other apps
** (testscrn, testdlgs) must look for correct name
*/
while (len >= 0 && szHelpFileName[len] != '\\' )
len--;
if (len != -1)
{
/* found a slash */
strcpy(&szHelpFileName[len+1],szHelp);
if (MOpenFile(szHelpFileName, &of, OF_EXIST) != -1)
return;
}
}
/* OF_PARSE doesn't find the file on the path like I would
** expect. Oh, well, open it and close it.
*/
if ((fh = MOpenFile(szHelp, &of, OF_READ | OF_SHARE_DENY_NONE)) != -1)
{
M_lclose(fh);
/* found it, save it */
OemToAnsi(of.szPathName,szHelpFileName);
return;
}
/* exhausted all possibilities to find the file */
szHelpFileName[0] = 0; /* no help file */
return;
}
void __CreateEasyWin(void)
{
if (__hPrev == 0)
{
CrtClass.hInstance = __hInstance;
CrtClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
CrtClass.hCursor = LoadCursor(NULL, IDC_ARROW);
CrtClass.hbrBackground = GetStockObject(WHITE_BRUSH);
RegisterClass(&CrtClass);
}
GetModuleFileName(__hInstance, _WindowTitle, sizeof(_WindowTitle));
OemToAnsi(_WindowTitle, _WindowTitle);
__ReadBufFPtr = _ReadBuf;
__WriteBufFPtr = _WriteBuf;
}
int IsFileNameValid(char* x)
//char *x;
{
WIN32_FIND_DATA fd;
HANDLE h;
#ifdef __RSXNT__ /* RSXNT/EMX C rtl uses OEM charset */
char *ansi_name = (char *)alloca(strlen(x) + 1);
OemToAnsi(x, ansi_name);
x = ansi_name;
#endif
if ((h = FindFirstFile(x, &fd)) == INVALID_HANDLE_VALUE)
return FALSE;
FindClose(h);
return TRUE;
}
/**
* liest den Text aus einer Datei.
*
* @param[in] file Dateihandle aus denen der Text geladen werden sollen
* @param[in] conversion Soll ggf. OEM-Charset in ANSI umgewandelt werden?
* @param[in] length Länge des Blocks (Wieviel Bytes sollen eingelesen werden?)
*
* @return liefert Null bei Erfolg, ungleich Null bei Fehler
*
* @todo Hmm nur temporärer Fix! ist dieses doofe Escape-zeichen am Ende der Files
*
* @author FloSoft
*/
int libsiedler2::ArchivItem_Text::load(FILE* file, bool conversion, unsigned int length)
{
if(file == NULL)
return 1;
// Aktuelle Position bestimmen
long pos = ftell(file);
if(length == 0)
{
// Länge der Datei bestimmen
fseek(file, 0, SEEK_END);
length = ftell(file) - pos;
fseek(file, pos, SEEK_SET);
}
std::vector<char>text(length + 1);
// Einlesen
if(libendian::le_read_c(&text.front(), length, file) != (int)length)
return 2;
/// TODO: Hmm nur temporärer Fix! ist dieses doofe Escape-zeichen am Ende der Files
if(text[length - 1] == 26)
text[length - 1] = 0;
if(conversion)
OemToAnsi(&text.front(), &text.front());
for(unsigned int i = 0; i < length; ++i)
{
if(text[i] == '@' && text[i + 1] == '@')
{
text[i] = '\r';
text[i + 1] = '\n';
}
}
this->text = &text.front();
// Text setzen
setName(this->text);
// Alles OK
return 0;
}
USHORT demCreateLabel(BYTE Drive, LPSTR lpszName)
{
CHAR szStr[32];
CHAR szAnsi[32];
CHAR szTmp[32];
CHAR *p, *s;
int i = 0;
sprintf(szStr, "%c:\\", Drive);
s = lpszName;
p = szTmp;
while(s) {
if(*s != '.') {
*p = *s;
i++;
p++;
}
else {
while(i < 8) {
*p++ = ' ';
i++;
}
}
s++;
if(i > 11)
break;
}
szTmp[i] = '\0';
OemToAnsi(szTmp, szAnsi);
if(!SetVolumeLabelA(szStr, szAnsi))
return(1);
else
return(0);
}
// turn a file, relative path or other into an absolute path
// This function copied from MFC 1.52
BOOL PASCAL _AfxFullPath(LPSTR lpszPathOut, LPCSTR lpszFileIn)
// lpszPathOut = buffer of _MAX_PATH
// lpszFileIn = file, relative path or absolute path
// (both in ANSI character set)
{
OFSTRUCT of;
if (OpenFile(lpszFileIn, &of, OF_PARSE) != HFILE_ERROR)
{
// of.szPathName is in the OEM character set
OemToAnsi(of.szPathName, lpszPathOut);
AnsiUpper(lpszPathOut); // paths in upper case just to be sure
return TRUE;
}
else
{
TRACE1("Warning: could not parse the path %Fs\n", lpszFileIn);
lstrcpy(lpszPathOut, lpszFileIn); // take it literally
AnsiUpper(lpszPathOut); // paths in upper case just to be sure
return FALSE;
}
}
int InternalEnumFiles(HZIP hZip)
{
int r=-1;
unz_global_info64 gi;
ZIPDECOMPRESSION *p=(ZIPDECOMPRESSION*)hZip;
int err=unzGetGlobalInfo64(p->hZip,&gi);
if (err == UNZ_OK)
{
for (uLong i=0; i<gi.number_entry; i++)
{
char filename_inzip[256];
unz_file_info64 file_info;
err=unzGetCurrentFileInfo64(p->hZip,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
if (err == UNZ_OK)
{
LPWSTR sourceFile=OemToUnicodeEx(filename_inzip,-1);
if (p->bOnlyEnum)
{
if (!p->bEnumAnsi)
r=(p->lpEnumProc(sourceFile)) ? 0 : -1;
else
{
char ansi_filename_inzip[256];
OemToAnsi(filename_inzip,ansi_filename_inzip);
r=(p->lpEnumProc((LPWSTR)ansi_filename_inzip)) ? 0 : -1;
}
}
else
r=ExtractCurrentFile(hZip,false);
MemFree(sourceFile);
}
unzGoToNextFile(p->hZip);
}
}
return r;
}
int ClearArchiveBit(char *name)
{
DWORD dwAttr;
#if defined(__RSXNT__) /* RSXNT/EMX C rtl uses OEM charset */
char *ansi_name = (char *)alloca(strlen(name) + 1);
OemToAnsi(name, ansi_name);
name = ansi_name;
#endif
dwAttr = GetFileAttributes(name);
if ( dwAttr == 0xFFFFFFFF ) {
fprintf(mesg, "zip diagnostic: GetFileAttributes failed\n");
return(0);
}
if (!SetFileAttributes(name, (DWORD)(dwAttr & ~FILE_ATTRIBUTE_ARCHIVE))) {
fprintf(mesg, "zip diagnostic: SetFileAttributes failed\n");
perror("SetFileAttributes");
return(0);
}
return(1);
}
local int FileTime2utime(FILETIME *pft, time_t *ut)
{
#ifndef NO_INT64
ULLNG64 NTtime;
NTtime = ((ULLNG64)pft->dwLowDateTime +
((ULLNG64)pft->dwHighDateTime << 32));
/* underflow and overflow handling */
#ifdef CHECK_UTIME_SIGNED_UNSIGNED
if ((time_t)0x80000000L < (time_t)0L)
{
if (NTtime < ((ULLNG64)UNIX_TIME_SMIN_LO +
((ULLNG64)UNIX_TIME_SMIN_HI << 32))) {
*ut = (time_t)LONG_MIN;
return FALSE;
}
if (NTtime > ((ULLNG64)UNIX_TIME_SMAX_LO +
((ULLNG64)UNIX_TIME_SMAX_HI << 32))) {
*ut = (time_t)LONG_MAX;
return FALSE;
}
}
else
#endif /* CHECK_UTIME_SIGNED_UNSIGNED */
{
if (NTtime < ((ULLNG64)UNIX_TIME_ZERO_LO +
((ULLNG64)UNIX_TIME_ZERO_HI << 32))) {
*ut = (time_t)0;
return FALSE;
}
if (NTtime > ((ULLNG64)UNIX_TIME_UMAX_LO +
((ULLNG64)UNIX_TIME_UMAX_HI << 32))) {
*ut = (time_t)ULONG_MAX;
return FALSE;
}
}
NTtime -= ((ULLNG64)UNIX_TIME_ZERO_LO +
((ULLNG64)UNIX_TIME_ZERO_HI << 32));
*ut = (time_t)(NTtime / (unsigned long)NT_QUANTA_PER_UNIX);
return TRUE;
#else /* NO_INT64 (64-bit integer arithmetics may not be supported) */
/* nonzero if `y' is a leap year, else zero */
# define leap(y) (((y)%4 == 0 && (y)%100 != 0) || (y)%400 == 0)
/* number of leap years from 1970 to `y' (not including `y' itself) */
# define nleap(y) (((y)-1969)/4 - ((y)-1901)/100 + ((y)-1601)/400)
/* daycount at the end of month[m-1] */
static ZCONST ush ydays[] =
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
time_t days;
SYSTEMTIME w32tm;
/* underflow and overflow handling */
#ifdef CHECK_UTIME_SIGNED_UNSIGNED
if ((time_t)0x80000000L < (time_t)0L)
{
if ((pft->dwHighDateTime < UNIX_TIME_SMIN_HI) ||
((pft->dwHighDateTime == UNIX_TIME_SMIN_HI) &&
(pft->dwLowDateTime < UNIX_TIME_SMIN_LO))) {
*ut = (time_t)LONG_MIN;
return FALSE;
if ((pft->dwHighDateTime > UNIX_TIME_SMAX_HI) ||
((pft->dwHighDateTime == UNIX_TIME_SMAX_HI) &&
(pft->dwLowDateTime > UNIX_TIME_SMAX_LO))) {
*ut = (time_t)LONG_MAX;
return FALSE;
}
}
else
#endif /* CHECK_UTIME_SIGNED_UNSIGNED */
{
if ((pft->dwHighDateTime < UNIX_TIME_ZERO_HI) ||
((pft->dwHighDateTime == UNIX_TIME_ZERO_HI) &&
(pft->dwLowDateTime < UNIX_TIME_ZERO_LO))) {
*ut = (time_t)0;
return FALSE;
}
if ((pft->dwHighDateTime > UNIX_TIME_UMAX_HI) ||
((pft->dwHighDateTime == UNIX_TIME_UMAX_HI) &&
(pft->dwLowDateTime > UNIX_TIME_UMAX_LO))) {
*ut = (time_t)ULONG_MAX;
return FALSE;
}
}
FileTimeToSystemTime(pft, &w32tm);
/* set `days' to the number of days into the year */
days = w32tm.wDay - 1 + ydays[w32tm.wMonth-1] +
(w32tm.wMonth > 2 && leap (w32tm.wYear));
/* now set `days' to the number of days since 1 Jan 1970 */
days += 365 * (time_t)(w32tm.wYear - 1970) +
(time_t)(nleap(w32tm.wYear));
*ut = (time_t)(86400L * days + 3600L * (time_t)w32tm.wHour +
(time_t)(60 * w32tm.wMinute + w32tm.wSecond));
return TRUE;
#endif /* ?NO_INT64 */
} /* end function FileTime2utime() */
#endif /* USE_EF_UT_TIME || NT_TZBUG_WORKAROUND */
#if (defined(NT_TZBUG_WORKAROUND) && defined(W32_STAT_BANDAID))
local int VFatFileTime2utime(const FILETIME *pft, time_t *ut)
{
FILETIME lft;
SYSTEMTIME w32tm;
struct tm ltm;
FileTimeToLocalFileTime(pft, &lft);
FileTimeToSystemTime(&lft, &w32tm);
/* underflow and overflow handling */
/* TODO: The range checks are not accurate, the actual limits may
* be off by one daylight-saving-time shift (typically 1 hour),
* depending on the current state of "is_dst".
*/
#ifdef CHECK_UTIME_SIGNED_UNSIGNED
if ((time_t)0x80000000L < (time_t)0L)
{
if ((pft->dwHighDateTime < UNIX_TIME_SMIN_HI) ||
((pft->dwHighDateTime == UNIX_TIME_SMIN_HI) &&
(pft->dwLowDateTime < UNIX_TIME_SMIN_LO))) {
*ut = (time_t)LONG_MIN;
return FALSE;
if ((pft->dwHighDateTime > UNIX_TIME_SMAX_HI) ||
((pft->dwHighDateTime == UNIX_TIME_SMAX_HI) &&
(pft->dwLowDateTime > UNIX_TIME_SMAX_LO))) {
*ut = (time_t)LONG_MAX;
return FALSE;
}
}
else
#endif /* CHECK_UTIME_SIGNED_UNSIGNED */
{
if ((pft->dwHighDateTime < UNIX_TIME_ZERO_HI) ||
((pft->dwHighDateTime == UNIX_TIME_ZERO_HI) &&
(pft->dwLowDateTime < UNIX_TIME_ZERO_LO))) {
*ut = (time_t)0;
return FALSE;
}
if ((pft->dwHighDateTime > UNIX_TIME_UMAX_HI) ||
((pft->dwHighDateTime == UNIX_TIME_UMAX_HI) &&
(pft->dwLowDateTime > UNIX_TIME_UMAX_LO))) {
*ut = (time_t)ULONG_MAX;
return FALSE;
}
}
ltm.tm_year = w32tm.wYear - 1900;
ltm.tm_mon = w32tm.wMonth - 1;
ltm.tm_mday = w32tm.wDay;
ltm.tm_hour = w32tm.wHour;
ltm.tm_min = w32tm.wMinute;
ltm.tm_sec = w32tm.wSecond;
ltm.tm_isdst = -1; /* let mktime determine if DST is in effect */
*ut = mktime(<m);
/* a cheap error check: mktime returns "(time_t)-1L" on conversion errors.
* Normally, we would have to apply a consistency check because "-1"
* could also be a valid time. But, it is quite unlikely to read back odd
* time numbers from file systems that store time stamps in DOS format.
* (The only known exception is creation time on VFAT partitions.)
*/
return (*ut != (time_t)-1L);
} /* end function VFatFileTime2utime() */
#endif /* NT_TZBUG_WORKAROUND && W32_STAT_BANDAID */
#if 0 /* Currently, this is not used at all */
long GetTheFileTime(char *name, iztimes *z_ut)
{
HANDLE h;
FILETIME Modft, Accft, Creft, lft;
WORD dh, dl;
#ifdef __RSXNT__ /* RSXNT/EMX C rtl uses OEM charset */
char *ansi_name = (char *)alloca(strlen(name) + 1);
OemToAnsi(name, ansi_name);
name = ansi_name;
#endif
h = CreateFile(name, FILE_READ_ATTRIBUTES, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if ( h != INVALID_HANDLE_VALUE ) {
BOOL ftOK = GetFileTime(h, &Creft, &Accft, &Modft);
CloseHandle(h);
#ifdef USE_EF_UT_TIME
if (ftOK && (z_ut != NULL)) {
FileTime2utime(&Modft, &(z_ut->mtime));
if (Accft.dwLowDateTime != 0 || Accft.dwHighDateTime != 0)
FileTime2utime(&Accft, &(z_ut->atime));
else
z_ut->atime = z_ut->mtime;
if (Creft.dwLowDateTime != 0 || Creft.dwHighDateTime != 0)
FileTime2utime(&Creft, &(z_ut->ctime));
else
z_ut->ctime = z_ut->mtime;
}
#endif
FileTimeToLocalFileTime(&ft, &lft);
FileTimeToDosDateTime(&lft, &dh, &dl);
return(dh<<16) | dl;
}
else
return 0L;
}
/////////////////////////////////////////////////////////////////////////////
// Liest ein TextMerkmal für das vorgegebene Objekt
HRESULT GetTextMerkmal (HPROJECT hPr, long lMCode, long lFirst, short iTyp, char **ppMText)
{
struct vom VOMSatz;
struct mkl MKLSatz;
DB_ADDR dbaVOM(hPr);
DB_ADDR dbaMKL(hPr);
long iLen = 0;
long VOMPrev = 0; // vorhergehender VOMSatz
long VOMNext; // nächster Satz
long zvommi = 0; // Zeiger auf MISatz
long RC;
bool fText = false;
// sicherheitshalber NULL setzen
VOMNext = 0L;
// TextPointer ausnullen
*ppMText = NULL;
if (lFirst == -1L) return S_OK;
switch (iTyp) {
case OBL_OLD: // normales ObjektMerkmal
{
struct obl OBLSatz;
DB_ADDR_OBL dbaOBL(hPr);
// Objektsatz einlesen
dbaOBL.rec_no = lFirst;
__ReadHR (dbaOBL, OBLSatz);
if (LocGetDBVersion(hPr) < VERSION05000008 && OBLSatz.status & SB_TEXTOBJ)
// alte DB und Textobjekt
return S_FALSE;
if (OBLSatz.status & SB_TEXTOBJIND)
fText = true;
VOMNext = OBLSatz.zovom; // erster Satz
}
break;
case IDL_OLD: // IdentifikatorMerkmal
{
if (LocGetDBVersion(hPr) < VERSION05000007)
return S_FALSE; // noch nicht implementiert
struct idl IDLSatz;
DB_ADDR_IDL dbaIDL(hPr);
// dbaIDL.file_no = IDL;
dbaIDL.rec_no = lFirst;
__ReadHR (dbaIDL, IDLSatz);
VOMNext = IDLSatz.zmerki;
}
break;
case SICHT: // SichtMerkmal
{
if (LocGetDBVersion(hPr) < VERSION05000007)
return S_FALSE; // noch nicht implementiert
struct sicht SICHTSatz;
DB_ADDR dbaSICHT(hPr);
dbaSICHT.file_no = SICHT;
dbaSICHT.rec_no = lFirst;
__ReadHR (dbaSICHT, SICHTSatz);
VOMNext = SICHTSatz.zmerkm;
}
break;
default:
return E_INVALIDARG;
}
// Verbindungsdatei zu Merkmalen (VOM) lesen und entspr. Satz suchen
dbaVOM.file_no = VOM;
dbaMKL.file_no = MKL;
dbaVOM.rec_no = 0;
MKLSatz.mk = 0;
do {
// VOMSatz lesen
VOMPrev = dbaVOM.rec_no;
if ((dbaVOM.rec_no = VOMNext) == 0)
break; // Ende der Kette: MCode nicht vorhanden
__ReadHR (dbaVOM, VOMSatz);
// MKLSatz lesen
dbaMKL.rec_no = VOMSatz.zvommk;
__ReadHR (dbaMKL, MKLSatz);
// nächster VOMSatz
VOMNext = VOMSatz.znmk;
} while (MKLSatz.mk != lMCode); // bis lMCode gefunden
// wenn für dieses Objekt MCode nicht exitiert: wieder raus mit Warnung
if (MKLSatz.mk != lMCode)
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
// Prüfen, ob MerkmalsTyp stimmt
if (MKLSatz.typ != 0) // kein TextMerkmal
return HRESULT_FROM_ERRCODE(WC_BADMKTYP);
// TextInfo einlesen
DBASSERTHR (GetTextMerkmalLen (hPr, VOMSatz.zvommi, &iLen));
if (iLen == 0 || iLen == -1) {
// entweder kein Text oder Text aus Bezugsobjekt
if (iTyp != OBL_OLD && SICHT != iTyp && IDL_OLD != iTyp) // kein ObjektMerkmal
return HRESULT_FROM_ERRCODE(WC_BADMKTYP);
ATLTRY(*ppMText = new char [1]);
if (*ppMText == NULL)
return E_OUTOFMEMORY;
**ppMText = '\0';
return S_OK; // leerer TextString gegeben
} else if (iLen < 0)
iLen = -iLen; // indirektes Textobjekt
iLen = ((iLen + 3) / 4) * 4; // auf long Grenze aufrunden
ATLTRY(*ppMText = new char[iLen+1]);
if (NULL == *ppMText)
return E_OUTOFMEMORY;
memset (*ppMText, '\0', (size_t)(iLen+1));
DBASSERTHR (GetTextFromDBT (hPr, VOMSatz.zvommi, *ppMText, iLen, fText));
OemToAnsi (*ppMText, *ppMText);
return S_OK;
}
