BOOL FTrjLabel(LPCSTR lsz, BYTE *rgb, UINT *pib) { UINT i; BYTE bOff; rglbl[clbl].lszLabel = lsz; rglbl[clbl].dwOff = *pib; clbl++; assert(clbl < CELEM_ARRAY(rglbl)); for (i=0; i<clblref; ) { if (_ftcscmp(lsz, rglblref[i].lszLabel) == 0) { bOff = *pib - (rglblref[i].dwOff + 1); rgb[rglblref[i].dwOff] = bOff; _fmemmove(&rglblref[i], &rglblref[i+1], (clblref-i-1)*sizeof(LABEL)); clblref--; } else { i++; } } return TRUE; }
void slidemsgTab(int howmany) { uint numnuked; numnuked = cfg.nmessages - howmany; _fmemmove(&msgTab1[howmany], msgTab1, (uint)(numnuked * (sizeof(*msgTab1)) )); _fmemmove(&msgTab2[howmany], msgTab2, (uint)(numnuked * (sizeof(*msgTab2)) )); /* _fmemmove(&msgTab3[howmany], msgTab3, (uint)(numnuked * (sizeof(*msgTab3)) )); */ _fmemmove(&msgTab4[howmany], msgTab4, (uint)(numnuked * (sizeof(*msgTab4)) )); _fmemmove(&msgTab5[howmany], msgTab5, (uint)(numnuked * (sizeof(*msgTab5)) )); _fmemmove(&msgTab6[howmany], msgTab6, (uint)(numnuked * (sizeof(*msgTab6)) )); _fmemmove(&msgTab7[howmany], msgTab7, (uint)(numnuked * (sizeof(*msgTab7)) )); _fmemmove(&msgTab8[howmany], msgTab8, (uint)(numnuked * (sizeof(*msgTab8)) )); /* _fmemmove(&msgTab9[howmany], msgTab9, (uint)(numnuked * (sizeof(*msgTab9)) )); */ }
void DIR_ReadNr (short num,struct DIR_rec *dest) { struct DIR_rec _far *zeiger=DIR_top,speicher; register short za,laenge,co; if (num<=DIR_eintraege && num>0) { laenge=sizeof(speicher); _fmemmove((void _far*)&speicher,zeiger,laenge); co=DIR_eintraege-num; for (za=1;za<=co;za++) { zeiger=speicher.vorher; _fmemmove((void _far*)&speicher,zeiger,laenge); } *dest=speicher; } }
//================================================================================== // _FormatPStr(void FAR *pdata, long count) // //================================================================================== static VOID NEAR PASCAL _FormatPStr(sBYTE FAR *pData, sBYTE FAR *msg) { int iMsgLen = _fstrlen(msg); int iDataLen = (uBYTE)pData[0]; if ((iMsgLen + iDataLen) < sizeof(SZMSGBUF)) iDataLen = sizeof(SZMSGBUF) - (uBYTE)iMsgLen; if (iDataLen > 0) _fmemmove(&(msg[iMsgLen]), pData + 1, iDataLen); iMsgLen += (uBYTE)pData[0]; msg[iMsgLen] = 0; // make sure to null terminate the string }
static void AppendMenuItemW(INT MenuGroup, PWSTR pString) { LPPOPUPLIST NewItem; if (PopupInUse+1 /*NULL element at end*/ >= PopupAllocated) { LPLPPOPUPLIST np; if ((np = _fcalloc(PopupAllocated+100, sizeof(LPPOPUPLIST))) == NULL) return; if (PopupInUse) { _fmemcpy(np, PopupList, PopupInUse*sizeof(LPPOPUPLIST)); _ffree(PopupList); } PopupList = np; PopupAllocated += 100; } NewItem = _fcalloc(1, sizeof(POPUPLIST) + wcslen(pString)*sizeof(WCHAR)); if (NewItem != NULL) { int i; wcscpy(NewItem->Name, pString); if ((i = wcslen(pString)) > MaxLen) MaxLen = i; NewItem->MenuGroup = (BYTE)MenuGroup; /*binary array search...*/ { int i, d; if (PopupInUse) { BOOL Less; for (d=PopupInUse-1; d & (d-1); d &= d-1); /*d = largest power of 2 less than PopupInUse*/ i = d; if (i) i += i-1; for (;;) { Less = i < PopupInUse && ( PopupList[i]->MenuGroup < MenuGroup || (PopupList[i]->MenuGroup == MenuGroup && lstrcmpiW(PopupList[i]->Name, pString) < 0)); if (Less) i += d; else i -= d; if (!d) break; d >>= 1; } if (Less) ++i; } else i = 0; if (i < PopupInUse) _fmemmove(PopupList+i+1, PopupList+i, (PopupInUse-i)*sizeof(LPPOPUPLIST)); assert(i >= 0); assert(i < PopupAllocated); ++PopupInUse; PopupList[i] = NewItem; }
VOID DeleteMotion(LEVEL_DATA *pLevel, INT index) { INT i; BYTE *p; WORD wSize; POLYGON huge *pPolygon; if (index < 0 || index > pLevel->nMotions - 1) { return; } // // Update the motion index of affected polygons. // pPolygon = pLevel->pPolygonData; for(i = 0; i < pLevel->nPolygons; ++i) { if (pPolygon->motion_index == index) { pPolygon->motion_index = -1; } else if (pPolygon->motion_index > index) { --pPolygon->motion_index; } ++pPolygon; } // // Now delete the motion. // p = (BYTE *)(&pLevel->pMotionData[index]); wSize = (pLevel->nMotions - index - 1) * sizeof(MOTION); if (wSize > 0) { _fmemmove(p, p + sizeof(MOTION), wSize); } --pLevel->nMotions; pLevel->bRebuildZone = TRUE; return; } // DeleteMotion
void DIR_ReleaseAll(void) { struct DIR_rec speicher; size_t laenge; while (DIR_eintraege>0) { laenge=sizeof(speicher); _fmemmove((void _far*)&speicher,DIR_top,laenge); _ffree(DIR_top); DIR_top=speicher.vorher; DIR_eintraege--; } }
/*-------------------------------------------------------------------------- * Function: _SetMemoryString * Expects: HWND hDlg * LPDLGVALS lpDlgVals; * Returns: nothing * Purpose: To Set the static string for the 'Memory display' of the assert * dialog box. * History: 11/7/94 Initial Revision (mdh) *-------------------------------------------------------------------------- */ static VOID NEAR PASCAL _SetMemoryString( HWND hDlg, LPDLGVALS lpdlgVals ) { char szTmp[32]; SZMSGBUF szBuf; if (lpdlgVals->ulCount > 0) { _NumToHexStr((long)lpdlgVals->lpvData, szTmp, 8); _fstrcpy(szBuf, _szMemoryMessage); _fmemmove(&(szBuf[kAddressOffset]), szTmp, _fstrlen(szTmp)); switch (lpdlgVals->ulFormat) { case 'b': case 'B': _FormatBytes(((sBYTE FAR*)lpdlgVals->lpvData), lpdlgVals->ulCount, (sBYTE FAR*)szBuf); break; case 'w': case 'W': _FormatWords(((sBYTE FAR*)lpdlgVals->lpvData), lpdlgVals->ulCount, (sBYTE FAR*)szBuf); break; case 'l': case 'L': _FormatLongs(((sBYTE FAR*)lpdlgVals->lpvData), lpdlgVals->ulCount, (sBYTE FAR*)szBuf); break; case 's': case 'S': _FormatCStr(((sBYTE FAR*)lpdlgVals->lpvData), szBuf); break; case 'p': case 'P': _FormatPStr(((sBYTE FAR*)lpdlgVals->lpvData), szBuf); break; } } else *szBuf = 0; // Null terminate the string. SetWindowText( GetDlgItem( hDlg, DLGID_MEMORYTEXT ), szBuf ); }
void env_subVarOffset(word segm, word offset) { register unsigned moveStart; DBG_ENTER("env_subVarOffset", Suppl_env) DBG_ARGUMENTS( ("env=%u, ofs=%u", segm, offset) ) chkMem assert(segm); assert(offset < env_endOfVars(segm)); moveStart = offset + env_varlen(segm, offset); _fmemmove(MK_FP(segm, offset), MK_FP(segm, moveStart), env_firstFree(segm) - moveStart); chkMem DBG_EXIT }
VOID DeleteMark(LEVEL_DATA *pLevel, INT index) { BYTE *p; WORD wSize; if (index < 0 || index > pLevel->nMarks - 1) { return; } p = (BYTE *)(&pLevel->pMarkData[index]); wSize = (pLevel->nMarks - index - 1) * sizeof(MARK); if (wSize > 0) { _fmemmove(p, p + sizeof(MARK), wSize); } --pLevel->nMarks; return; } // DeleteMark
// add a variable to the environment or alias to the alias list int PASCAL add_list( LPTSTR pszVariable, TCHAR _far *pchList ) { LPTSTR pszLine; TCHAR _far *pszVarName, _far *pszArgument, _far *pszEndOfList, _far *pszLastVariable; unsigned int uLength; int nError = 0; if ( pchList == 0L ) pchList = glpEnvironment; pszLine = pszVariable; if ( *pszLine == _TEXT('=') ) { return ( error( ERROR_4DOS_BAD_SYNTAX, pszVariable )); } for ( ; (( *pszLine ) && ( *pszLine != _TEXT('=') )); pszLine++ ) { if ( pchList != glpEnvironment ) { if ( iswhite( *pszLine )) { strcpy( pszLine, skipspace( pszLine ) ); break; } } else // ensure environment entry is in upper case *pszLine = (unsigned char)_ctoupper( *pszLine ); } // stupid kludge to strip quotes from PATH for compatibility with // COMMAND.COM if (( fWin95 ) && ( pchList == glpEnvironment )) { char szVarName[8]; if (( uLength = ( pszLine - pszVariable )) > 7 ) uLength = 7; sprintf( szVarName, "%.*s", uLength, pszVariable ); if ( stricmp( szVarName, PATH_VAR ) == 0 ) StripQuotes( pszLine ); } if ( *pszLine == _TEXT('=') ) { // point to the first char of the argument pszLine++; // collapse whitespace around '=' in aliases, but not in env // variables, for COMMAND.COM compatibility (set abc def= ghi) if ( pchList != glpEnvironment ) strcpy( pszLine, skipspace( pszLine )); } else if ( *pszLine ) { // add the missing '=' strins( pszLine, _TEXT("=") ); pszLine++; } // removing single back quotes at the beginning and end of an alias // argument (they're illegal there; the user is probably making a // mistake with ALIAS /R) if (( *pszLine == SINGLE_QUOTE ) && ( pchList != glpEnvironment )) { // remove leading single quote strcpy( pszLine, pszLine + 1 ); // remove trailing single quote if ((( uLength = strlen( pszLine )) != 0 ) && ( pszLine[--uLength] == SINGLE_QUOTE )) pszLine[uLength] = _TEXT('\0'); } // block other processes & threads while updating list if ( pchList != glpEnvironment ) { // disable task switches under Windows and DESQview CriticalSection( 1 ); } // get pointers to beginning & end of list space pszEndOfList = pchList + ((( pchList == glpAliasList ) ? gpIniptr->AliasSize : gpIniptr->EnvSize ) - 4 ); // get pointer to end of environment or alias variables pszLastVariable = end_of_env( pchList ); uLength = strlen( pszVariable ) + 1; // check for modification or deletion of existing entry if (( pszArgument = get_list( pszVariable, pchList )) != 0L ) { // get the start of the alias or variable name for ( pszVarName = pszArgument; (( pszVarName > pchList ) && ( pszVarName[-1] != _TEXT('\0') )); pszVarName-- ) ; if ( *pszLine == _TEXT('\0') ) { // delete an alias or environment variable _fmemmove( pszVarName, next_env( pszVarName ), (unsigned int)( (ULONG_PTR)pszLastVariable - (ULONG_PTR)next_env(pszVarName)) + sizeof(TCHAR)); } else { // get the relative length (vs. the old variable) uLength = strlen( pszLine ) - _fstrlen( pszArgument ); } } if ( *pszLine != _TEXT('\0') ) { // check for out of space if (( pszLastVariable + ( uLength * sizeof(TCHAR) )) >= pszEndOfList ) { if ( pchList == glpAliasList ) nError = error( ERROR_4DOS_OUT_OF_ALIAS, NULL ); else if ( pchList == glpEnvironment ) nError = error( ERROR_4DOS_OUT_OF_ENVIRONMENT, NULL); else nError = error( ERROR_NOT_ENOUGH_MEMORY, NULL ); goto add_bye; } if ( pszArgument != 0L ) { // modify an existing value // adjust the space & insert new value pszVarName = next_env( pszVarName ); _fmemmove(( pszVarName + uLength ), pszVarName, (unsigned int)(( (ULONG_PTR)pszLastVariable - (ULONG_PTR)pszVarName ) + sizeof(TCHAR) )); _fstrcpy( pszArgument, pszLine ); } else { // put it at the end & add an extra null _fstrcpy( pszLastVariable, pszVariable ); pszLastVariable[uLength] = _TEXT('\0'); } } add_bye: if ( pchList != glpEnvironment ) { // re-enable task switches under Windows and DESQview CriticalSection( 0 ); } return nError; }
DWORD FAR PASCAL OBSVocSyn (float FAR *lpflSrcBuf, DWORD ulOutDen, long lSmpTim, DWORD ulWinPts, DWORD ulFFTPts, float flPchShf, float flSynThr, LPOBSB pobOBSBlk) { MGAFLT FAR *lpmaMGABuf; MGAFLT FAR *lpmaPrvBuf; float FAR *lpflCosBuf; float FAR *lpflIdxBuf; float FAR *lpflOutBuf; DWORD ulOscCnt; float flPchInc; float flFrqInc; float flAmpInc; float flCurAmp; float flCurFrq; float flCurIdx; DWORD ulCpxPts = ulFFTPts >> 1; DWORD uli; DWORD ulj; /********************************************************************/ /********************************************************************/ ulOscCnt = (DWORD) ((flPchShf > 1) ? ulCpxPts / flPchShf : ulCpxPts); flPchInc = flPchShf * pobOBSBlk->flTabInc; /********************************************************************/ /********************************************************************/ if (!(lpmaPrvBuf = GloMemLck (pobOBSBlk->mhPrvBuf))) { return (0L); } if (!(lpflCosBuf = GloMemLck (pobOBSBlk->mhCosBuf))) { GloMemUnL (pobOBSBlk->mhPrvBuf); return (0L); } if (!(lpflIdxBuf = GloMemLck (pobOBSBlk->mhIdxBuf))) { GloMemUnL (pobOBSBlk->mhPrvBuf); GloMemUnL (pobOBSBlk->mhCosBuf); return (0L); } if (!(lpflOutBuf = GloMemLck (pobOBSBlk->mhWrkBuf))) { GloMemUnL (pobOBSBlk->mhPrvBuf); GloMemUnL (pobOBSBlk->mhCosBuf); GloMemUnL (pobOBSBlk->mhIdxBuf); return (0L); } lpmaMGABuf = (LPVOID) lpflSrcBuf; /********************************************************************/ /* Generate I output samples from input Mag / Ang buffer */ /********************************************************************/ for (uli=0L; uli < ulOscCnt; uli++) { lpmaMGABuf[uli].flAng *= flPchInc; flCurFrq = lpmaPrvBuf[uli].flAng; flFrqInc = (lpmaMGABuf[uli].flAng - flCurFrq) / (float) ulOutDen; flCurIdx = lpflIdxBuf[uli]; /****************************************************************/ /****************************************************************/ if (lpmaMGABuf[uli].flMag < flSynThr) lpmaMGABuf[uli].flMag = 0; flCurAmp = lpmaPrvBuf[uli].flMag; flAmpInc = (lpmaMGABuf[uli].flMag - flCurAmp) / (float) ulOutDen; /****************************************************************/ /* Inc Frq / Amp from beginning to end of output */ /****************************************************************/ if (flAmpInc || flCurAmp) for (ulj=0; ulj < ulOutDen; ulj++) { // lpflOutBuf[ulj] += flCurAmp * cos (db2PI * flCurIdx / OBSCOSTAB); lpflOutBuf[ulj] += flCurAmp * lpflCosBuf[(DWORD) flCurIdx]; flCurAmp += flAmpInc; flCurIdx += (flCurFrq + ulj * flFrqInc); while (flCurIdx >= OBSCOSTAB) flCurIdx -= (float) OBSCOSTAB; while (flCurIdx < 0) flCurIdx += (float) OBSCOSTAB; } lpmaPrvBuf[uli] = lpmaMGABuf[uli]; lpflIdxBuf[uli] = flCurIdx; } /********************************************************************/ /* If output time >= 0, output first batch & shift remaining left */ /********************************************************************/ if (lSmpTim) _fmemcpy (lpflSrcBuf, lpflOutBuf, (WORD) ulOutDen * sizeof (*lpflOutBuf)); _fmemmove (lpflOutBuf, &lpflOutBuf[ulOutDen], (WORD) (ulWinPts - ulOutDen) * sizeof (*lpflOutBuf)); for (uli=ulWinPts - ulOutDen; uli<ulWinPts; uli++) lpflOutBuf[uli] = 0; /********************************************************************/ /********************************************************************/ GloMemUnL (pobOBSBlk->mhPrvBuf); GloMemUnL (pobOBSBlk->mhCosBuf); GloMemUnL (pobOBSBlk->mhIdxBuf); GloMemUnL (pobOBSBlk->mhWrkBuf); /********************************************************************/ /********************************************************************/ return ((lSmpTim >= 0L) ? ulOutDen : 0L); }
VOID DeleteGroup(LEVEL_DATA *pLevel, INT index) { INT i; BYTE *p; WORD wSize; POLYGON huge *pPolygon; VERTEX huge *pVertex; if (index < 0 || index > pLevel->nGroups - 1) { return; } // // Update the group index of affected polygons. // pPolygon = pLevel->pPolygonData; for(i = 0; i < pLevel->nPolygons; ++i) { if (pPolygon->group_index == index) { pPolygon->group_index = -1; } else if (pPolygon->group_index > index) { --pPolygon->group_index; } ++pPolygon; } // // Update the group index of affected vertices. // pVertex = pLevel->pVertexData; for(i = 0; i < pLevel->nVertices; ++i) { if (pVertex->group_index == index) { pVertex->group_index = -1; } else if (pVertex->group_index > index) { --pVertex->group_index; } ++pVertex; } // // Now delete the group. // p = (BYTE *)(&pLevel->pGroupData[index]); wSize = (pLevel->nGroups - index - 1) * sizeof(GROUP); if (wSize > 0) { _fmemmove(p, p + sizeof(GROUP), wSize); } --pLevel->nGroups; return; } // DeleteGroup
VOID DeleteTrigger(LEVEL_DATA *pLevel, INT index) { INT i; BYTE *p; WORD wSize; VERTEX huge *pVertex; if (index < 0 || index > pLevel->nTriggers - 1) { return; } // // Update the trigger index of affected motions. // for(i = 0; i < pLevel->nMotions; ++i) { if (pLevel->pMotionData[i].trigger_index == index) { pLevel->pMotionData[i].trigger_index = -1; } else if (pLevel->pMotionData[i].trigger_index > index) { --pLevel->pMotionData[i].trigger_index; } } // // Update the trigger index of affected vertices. // pVertex = pLevel->pVertexData; for(i = 0; i < pLevel->nVertices; ++i) { if (pVertex->trigger_index == index) { pVertex->trigger_index = -1; } else if (pVertex->trigger_index > index) { --pVertex->trigger_index; } ++pVertex; } // // Now delete the trigger. // p = (BYTE *)(&pLevel->pTriggerData[index]); wSize = (WORD)(pLevel->nTriggers - index - 1) * sizeof(TRIGGER); if (wSize > 0) { _fmemmove(p, p + sizeof(TRIGGER), wSize); } --pLevel->nTriggers; pLevel->bRebuildZone = TRUE; return; } // DeleteTrigger
WORD FAR PASCAL EffWinRsp (WINTYP usWinTyp, CPXFLT FAR *lpXfrBuf, DWORD ulXfrLen) { /********************************************************************/ /* Note: There appears to be no advantage in expanding window first */ /********************************************************************/ float flWinLen =1; // #define MINMULSIZ 2 // #define MAXMULSIZ 8 #define MINMULSIZ 1 #define MAXMULSIZ 1 VISMEMHDL mhInfHdl; CPXFLT FAR *lpInfBuf; DWORD ulInfLen; DWORD uli; /********************************************************************/ /* Allocate "infinite" filter bufffer */ /* If no space, simply leave original in place */ /* Note limit size to 64K until all routines can handle large blks */ /********************************************************************/ if ((VISMEMHDL) NULL == (mhInfHdl = GloAloBlk (GMEM_MOVEABLE, ulXfrLen * sizeof (*lpXfrBuf), MINMULSIZ, min (0x8000L / (ulXfrLen * sizeof (*lpXfrBuf)), MAXMULSIZ), &ulInfLen))) return ((WORD) -1); if (NULL == (lpInfBuf = GloMemLck (mhInfHdl))) { GloAloRel (mhInfHdl); return ((WORD) -1); } ulInfLen /= sizeof (*lpInfBuf); if ((flWinLen <= 0) || (flWinLen > 1)) return ((WORD) -1); /********************************************************************/ /* Round infinite FFT point count to power of two */ /********************************************************************/ ulInfLen = (DWORD) pow (2, (floor (LOGBASTWO (ulInfLen)))); /********************************************************************/ /* Duplicate filter and extend with zeros */ /********************************************************************/ _fmemmove (lpInfBuf, lpXfrBuf, (WORD) (ulXfrLen * sizeof (*lpXfrBuf))); for (uli=ulXfrLen; uli < ulInfLen; uli++) lpInfBuf[uli].flRea = lpInfBuf[uli].flImg = 0; /********************************************************************/ /* Transform to time domain & window. */ /* Truncate series and return to frequency domain */ /* Note: Use asymetrical Hanning window (tail half of series) */ /********************************************************************/ EffFFTRea ((float FAR *) lpInfBuf, (WORD) ulInfLen, EFFFFTINV); ulXfrLen = (DWORD) (ulXfrLen * flWinLen); for (uli=0; uli < ulXfrLen; uli++) { float flHanWin = (float) EffFIRWin (usWinTyp, (WORD) ((ulXfrLen * 2) + 1), (WORD) (ulXfrLen + uli)); lpInfBuf[uli].flRea *= flHanWin; lpInfBuf[uli].flImg *= flHanWin; } for (uli=ulXfrLen; uli < ulInfLen; uli++) lpInfBuf[uli].flRea = lpInfBuf[uli].flImg = 0; ulXfrLen = (DWORD) (ulXfrLen / flWinLen); EffFFTRea ((float FAR *) lpInfBuf, (WORD) ulInfLen, EFFFFTFWD); /********************************************************************/ /* Copy back to source buffer */ /********************************************************************/ _fmemmove (lpXfrBuf, lpInfBuf, (WORD) (ulXfrLen * sizeof (*lpXfrBuf))); /********************************************************************/ /********************************************************************/ GloUnLRel (mhInfHdl); return (0); }
void scFar* scFar scCDecl SCmemmove( void scFar* dst, const void scFar* src, long len ) { return _fmemmove( dst, src, (size_t)len ); }
void DIR_Make (char *name,unsigned attr) { struct DIR_rec ds,_far *zgr; size_t laenge=sizeof(ds); struct find_t fileinfo; char buf[30],drive; int aktdr; DIR_ReleaseAll(); /* LAUFWERKE EINLESEN */ /* Wenn laufwerk anwaehlbar, dann existiert es */ aktdr=_getdrive(); for(drive=1;drive<27;drive++) if(!_chdrive(drive)) { sprintf(ds.name,"[ %c: ]",drive+'A'-1); ds.driveident=1; ds.dirident=0; zgr=_fmalloc(laenge); if (zgr!=NULL) { ds.vorher=DIR_top; DIR_top=zgr; _fmemmove(DIR_top,&ds,laenge); DIR_eintraege++; } } _chdrive(aktdr); /* SUBDIRS EINLESEN EINLESEN */ ds.driveident=0; ds.dirident=1; if (!_dos_findfirst("*.*",_A_SUBDIR,&fileinfo)) do { if(fileinfo.attrib & _A_SUBDIR) { while (strlen(fileinfo.name)<12) strcat(fileinfo.name," "); strcpy(ds.name,"<"); strcat(ds.name,fileinfo.name); strcat(ds.name,">"); zgr=_fmalloc(laenge); if (zgr!=NULL && strcmp(ds.name,"<. >")) { ds.vorher=DIR_top; DIR_top=zgr; _fmemmove(DIR_top,&ds,laenge); DIR_eintraege++; } } } while(!_dos_findnext(&fileinfo)); /* FILES EINLESEN */ ds.driveident=0; ds.dirident=0; if (!_dos_findfirst(name,attr,&fileinfo)) do { if(!(fileinfo.attrib & _A_SUBDIR)) { /* Eintrag */ while (strlen(fileinfo.name)<12) strcat(fileinfo.name," "); strcpy(ds.name," "); strcat(ds.name,fileinfo.name); strcat(ds.name," "); ds.laenge=fileinfo.size; sprintf(buf,"%2.2d/%02.2d/%02.2d",fileinfo.wr_date & 0x1f, (fileinfo.wr_date>>5) & 0x0f,(fileinfo.wr_date>>9)+80); strcpy(ds.datum,buf); zgr=_fmalloc(laenge); if (zgr!=NULL) { ds.vorher=DIR_top; DIR_top=zgr; _fmemmove(DIR_top,&ds,laenge); DIR_eintraege++; } } } while(!_dos_findnext(&fileinfo)); }