FString FUnrealSourceFile::GetGeneratedMacroName(int32 LineNumber, const TCHAR* Suffix) const
{
if (Suffix != nullptr)
{
return FString::Printf(TEXT("%s_%d%s"), *GetFileId(), LineNumber, Suffix);
}
return FString::Printf(TEXT("%s_%d"), *GetFileId(), LineNumber);
}
void CLua::ConfigClose(char *pFileDir)
{
int Id = GetFileId(pFileDir);
if (Id == -1)
return;
m_aLuaFiles[Id].ConfigClose();
}
//-----------------------------------------------------------------------------
// Fills all gaps in a film track with slugs
//-----------------------------------------------------------------------------
void CDmeTrack::FillAllGapsWithSlugs( const char *pSlugName, DmeTime_t startTime, DmeTime_t endTime )
{
if ( !IsFilmTrack() )
return;
FixOverlaps();
// Create temporary slugs to fill in the gaps
bool bSlugAdded = false;
int c = GetClipCount();
for ( int i = 0; i < c; ++i )
{
CDmeClip *pFilmClip = GetClip(i);
DmeTime_t clipStartTime = pFilmClip->GetStartTime();
if ( clipStartTime > startTime )
{
// There's a gap, create a slug
CDmeFilmClip *pSlug = CreateSlugClip( pSlugName, startTime, clipStartTime, GetFileId() );
// This will add the slug to the end; so we don't have to
// worry about iterating over it (we've cached off the initial count)
AddClip( pSlug );
bSlugAdded = true;
}
startTime = pFilmClip->GetEndTime();
}
if ( endTime > startTime )
{
// There's a gap, create a temporary slug
CDmeFilmClip *pSlug = CreateSlugClip( pSlugName, startTime, endTime, GetFileId() );
// This will add the slug to the end; so we don't have to
// worry about iterating over it (we've cached off the initial count)
AddClip( pSlug );
bSlugAdded = true;
}
if ( bSlugAdded )
{
FixOverlaps();
}
}
void WriteOutputFile (const StrBuf* Data, const Collection* A, const Bitmap* B)
/* Write the contents of Data to a file. Format, file name etc. must be given
** as attributes in A. If no format is given, the function tries to autodetect
** it by using the extension of the file name. The bitmap passed to the
** function is the bitmap used as source of the conversion. It may be used to
** determine the bitmap properties for documentation purposes.
*/
{
const FileId* F;
/* Get the file format from the command line */
const char* Format = GetAttrVal (A, "format");
if (Format != 0) {
/* Format is given, search for it in the table. */
F = bsearch (Format,
FormatTable,
sizeof (FormatTable) / sizeof (FormatTable[0]),
sizeof (FormatTable[0]),
CompareFileId);
if (F == 0) {
Error ("Unknown output format `%s'", Format);
}
} else {
/* No format given, use file name extension */
const char* Name = NeedAttrVal (A, "name", "write");
F = GetFileId (Name, FormatTable,
sizeof (FormatTable) / sizeof (FormatTable[0]));
/* Found? */
if (F == 0) {
Error ("Cannot determine file format of output file `%s'", Name);
}
}
/* Call the format specific write */
OutputFormatTable[F->Id].Write (Data, A, B);
}
LSTATUS UpdateFile(CString lpExistingFileName, CString lpNewFileName)
{
if (GetFileType(lpNewFileName) != PathIsDir)
{
return ERROR_FILE_NOT_FOUND;
}
LSTATUS lStatus = ERROR_FILE_NOT_FOUND;
CString NewFile, OldFile;
WIN32_FIND_DATAW FindFileData = {};
HANDLE hFindFile = FindFirstFileW(lpNewFileName + L"*", &FindFileData);
FILE_INTERNAL_INFORMATION IdNew, IdOld;
if (hFindFile != INVALID_HANDLE_VALUE)
{
do
{
if (FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
{
if (_IsDots(FindFileData.cFileName) == 0)
{
auto lStatusTmp = UpdateFile(lpExistingFileName + FindFileData.cFileName + L"\\", lpNewFileName + FindFileData.cFileName + L"\\");
if (lStatusTmp)
{
lStatus = lStatusTmp;
}
}
}
else
{
//TempFile = TempPath + FindFileData.cFileName;
OldFile = lpExistingFileName + FindFileData.cFileName;
NewFile = lpNewFileName + FindFileData.cFileName;
////////////////////////////////////////
//先检查文件是否为同一个文件
if (auto Status = GetFileId(NewFile, NULL, &IdNew))
{
lStatus = RtlNtStatusToDosError(Status);
continue;
}
if (auto Status = GetFileId(OldFile, NULL, &IdOld))
{
lStatus = RtlNtStatusToDosError(Status);
continue;
}
if (IdNew.IndexNumber.QuadPart != IdOld.IndexNumber.QuadPart)
{
if (DirectGetOsMinVersion() >= MakeMiniVersion(6, 1))
{
if (!MoveFileEx(NewFile, OldFile, MOVEFILE_CREATE_HARDLINK | MOVEFILE_REPLACE_EXISTING))
{
lStatus = GetLastError_s();
}
}
else
{
//Vista不支持直接替换，在Host为Vista时则使用事物处理来保证操作原子性
auto hTransaction = CreateTransaction(NULL, 0, 0, 0, 0, INFINITE, nullptr);
if (hTransaction == INVALID_HANDLE_VALUE)
{
lStatus = GetLastError_s();
}
else
{
if (DeleteFileTransactedW(OldFile, hTransaction)==FALSE || CreateHardLinkTransactedW(OldFile, NewFile,nullptr, hTransaction)==FALSE)
{
lStatus = GetLastError_s();
}
else
{
if (!CommitTransactionAsync(hTransaction))
{
lStatus = GetLastError_s();
}
}
CloseHandle(hTransaction);
}
}
}
}
} while (FindNextFile(hFindFile, &FindFileData));
FindClose(hFindFile);
}
return lStatus;
}
/******************************************************************************
* *
* BOOL ParseFunctionScope(int fd, int fs, BYTE *pBuf) *
* *
*******************************************************************************
*
* Loads and parses function scope fields and variables
*
* Where:
* fd - symbol table file descriptor (to write to)
* fs - strings file (to write to)
* pBuf - buffer containing the ELF file
*
* Returns:
* TRUE - Function scope parsed and stored
* FALSE - Critical error
*
******************************************************************************/
BOOL ParseFunctionScope(int fd, int fs, BYTE *pBuf)
{
TSYMFNSCOPE Header; // Function scope section header
TSYMFNSCOPE1 list; // Function scope record
WORD file_id = 0; // Current file ID number
long fileOffset = 0; // Temp file offset position
WORD nTokens = 0; // Number of tokens in a function
BOOL fInFunction = FALSE; // Are we inside a function scope?
int nCurrentSection; // Current string section offset
int nSectionSize; // Current section string size
Elf32_Ehdr *pElfHeader; // ELF header
Elf32_Shdr *Sec; // Section header array
Elf32_Shdr *SecName; // Section header string table
Elf32_Shdr *SecCurr; // Current section
Elf32_Shdr *SecStab = NULL; // Section .STAB
Elf32_Shdr *SecStabstr = NULL; // Section .STABSTR
Elf32_Shdr *SecSymtab = NULL; // Section .SYMTAB
Elf32_Shdr *SecStrtab = NULL; // Section .STRTAB
struct stat fd_stat; // ELF file stats
StabEntry *pStab; // Pointer to a stab entry
char *pStr; // Pointer to a stab string
char *pSoDir = ""; // Source code directory
char *pSo = ""; // Current source file
int i;
VERBOSE2 printf("=============================================================================\n");
VERBOSE2 printf("|| PARSE FUNCTION SCOPE ||\n");
VERBOSE2 printf("=============================================================================\n");
VERBOSE1 printf("Parsing function scope.\n");
pElfHeader = (Elf32_Ehdr *) pBuf;
// Ok, we have the complete file inside the buffer...
// Find the section header and the string table of section names
Sec = (Elf32_Shdr *) &pBuf[pElfHeader->e_shoff];
SecName = &Sec[pElfHeader->e_shstrndx];
for( i=1; i<pElfHeader->e_shnum; i++ )
{
SecCurr = &Sec[i];
pStr = (char *)pBuf + SecName->sh_offset + SecCurr->sh_name;
if( strcmp(".stab", pStr)==0 )
SecStab = SecCurr;
else
if( strcmp(".stabstr", pStr)==0 )
SecStabstr = SecCurr;
else
if( strcmp(".symtab", pStr)==0 )
SecSymtab = SecCurr;
else
if( strcmp(".strtab", pStr)==0 )
SecStrtab = SecCurr;
}
//=========================
// Parse STABS
//=========================
// We parse STABS exactly as we do a generic ELF section parsing,
// but here we extract only basic function parameters and relevant tokens
if( SecStab && SecStabstr )
{
// Parse stab section
pStab = (StabEntry *) ((char*)pElfHeader + SecStab->sh_offset);
i = SecStab->sh_size / sizeof(StabEntry);
nCurrentSection = 0;
nSectionSize = 0;
while( i-- )
{
pStr = (char *)pElfHeader + SecStabstr->sh_offset + pStab->n_strx + nCurrentSection;
switch( pStab->n_type )
{
// 0x00 (N_UNDEF) is actually storing the current section string size
case N_UNDF:
// We hit another string section, need to advance the string offset of the previous section
nCurrentSection += nSectionSize;
// Save the (new) currect string section size
nSectionSize = pStab->n_value;
VERBOSE2 printf("HdrSym size: %lX\n", pStab->n_value);
break;
case N_FUN:
VERBOSE2 printf("FUN---");
if( *pStr==0 )
{
// Function end
VERBOSE2 printf("END--------- +%lX\n\n", pStab->n_value);
// At this point we know the total size of the header
// as well as the function ending address. Fill in the
// missing information and rewrite the header
Header.h.dwSize = sizeof(TSYMFNSCOPE) + sizeof(TSYMFNSCOPE1) * (nTokens-1);
Header.dwEndAddress = Header.dwStartAddress + pStab->n_value - 1;
Header.nTokens = nTokens;
// Reposition the file pointer to the start of the header
lseek(fd, fileOffset, SEEK_SET);
write(fd, &Header, sizeof(TSYMFNSCOPE)-sizeof(TSYMFNSCOPE1));
lseek(fd, 0, SEEK_END);
fInFunction = FALSE;
}
else
{
// We will write a header but later, on an function end,
// rewind and rewite it with the complete information
// This we do so we can simply keep adding file tokens as
// TSYMFNSCOPE1 array...
Header.h.hType = HTYPE_FUNCTION_SCOPE;
Header.h.dwSize = sizeof(TSYMFNSCOPE)-sizeof(TSYMFNSCOPE1);
// Copy the function name into the strings
Header.pName = dfs;
write(fs, pStr, strlen(pStr)+1);
dfs += strlen(pStr)+1;
Header.file_id = file_id;
Header.dwStartAddress = pStab->n_value;
Header.dwEndAddress = 0; // To be written later
Header.nTokens = 0; // To be written later
// If the start address is not defined (0?) and this is an object file
// (kernel module), we can search the global symbols for the address
if( Header.dwStartAddress==0 && GlobalsName2Address(&Header.dwStartAddress, pStr) )
;
// Print function start & name
VERBOSE2 printf("START-%08X--%s\n", Header.dwStartAddress, pStr);
nTokens = 0;
// Get the current file position so we can come back later
// Get the file stats
fstat(fd, &fd_stat);
fileOffset = fd_stat.st_size;
// Write the header first time
write(fd, &Header, sizeof(TSYMFNSCOPE)-sizeof(TSYMFNSCOPE1));
fInFunction = TRUE;
}
break;
case N_SO:
VERBOSE2 printf("SO ");
if( *pStr==0 )
{
// Empty name - end of source file
VERBOSE2 printf("End of source. Text section offset: %08lX\n", pStab->n_value);
VERBOSE2 printf("=========================================================\n");
}
else
{
if( *(pStr + strlen(pStr) - 1)=='/' )
{
// Directory
VERBOSE2 printf("Source directory: %s\n", pStr);
// Store the pointer to a directory so we can use it later for
// SO and SOL stabs
pSoDir = pStr;
}
else
{
// File
VERBOSE2 printf("Source file: %s\n", pStr );
// Store the pointer to a file as a current source file
pSo = pStr;
}
file_id = GetFileId(pSoDir, pSo);
}
break;
// Parameter symbol to a function
case N_PSYM:
VERBOSE2 printf("PSYM ");
VERBOSE2 printf("line: %d PARAM [EBP+%lX] %s\n", pStab->n_desc, pStab->n_value, pStr);
// Write out one token record
list.TokType = TOKTYPE_PARAM;
list.param = pStab->n_value;
list.pName = dfs;
write(fs, pStr, strlen(pStr)+1);
dfs += strlen(pStr)+1;
write(fd, &list, sizeof(TSYMFNSCOPE1));
nTokens++;
break;
// Register variable
case N_RSYM:
VERBOSE2 printf("RSYM REGISTER VARIABLE ");
VERBOSE2 printf("%s in %ld\n", pStr, pStab->n_value);
// Write out one token record
list.TokType = TOKTYPE_RSYM;
list.param = pStab->n_value;
list.pName = dfs;
write(fs, pStr, strlen(pStr)+1);
dfs += strlen(pStr)+1;
write(fd, &list, sizeof(TSYMFNSCOPE1));
nTokens++;
break;
// Local symbol: this symbol is shared with typedefs, but if the
// pStab->n_value != 0, it is a local symbol
case N_LSYM:
if( pStab->n_value==0 )
break;
VERBOSE2 printf("LSYM ");
VERBOSE2 printf("line: %2d LOCAL_VARIABLE [EBP+%02lX] %s\n", pStab->n_desc, pStab->n_value, pStr);
// n_value != 0 -> variable address relative to EBP
// n_desc = line number where the symbol is declared
// Write out one token record
list.TokType = TOKTYPE_LSYM;
list.param = pStab->n_value;
list.pName = dfs;
write(fs, pStr, strlen(pStr)+1);
dfs += strlen(pStr)+1;
write(fd, &list, sizeof(TSYMFNSCOPE1));
nTokens++;
break;
// Local static symbol in the BSS segment
case N_LCSYM:
// If we are not within a function scope, it is a local variable
if(fInFunction)
{
list.bSegment= GlobalsName2SectionNumber(pStr);
VERBOSE2 printf("LCSYM ");
VERBOSE2 printf("line: %d seg:%d %08lX %s\n", pStab->n_desc, list.bSegment, pStab->n_value, pStr);
// Write out one token record
list.TokType = TOKTYPE_LCSYM;
list.param = pStab->n_value;
list.pName = dfs;
write(fs, pStr, strlen(pStr)+1);
dfs += strlen(pStr)+1;
write(fd, &list, sizeof(TSYMFNSCOPE1));
nTokens++;
}
break;
// Left-bracket: open a new scope
case N_LBRAC:
VERBOSE2 printf("LBRAC +%lX { (%d)\n", pStab->n_value, pStab->n_desc);
// Write out one token record
list.TokType = TOKTYPE_LBRAC;
list.param = pStab->n_value;
list.pName = 0; // Not used
write(fd, &list, sizeof(TSYMFNSCOPE1));
nTokens++;
break;
// Right-bracket: close a scope
case N_RBRAC:
VERBOSE2 printf("RBRAC +%lX }\n", pStab->n_value);
// Write out one token record
list.TokType = TOKTYPE_RBRAC;
list.param = pStab->n_value;
list.pName = 0; // Not used
write(fd, &list, sizeof(TSYMFNSCOPE1));
nTokens++;
break;
// We can ignore N_SOL (change of source) since the function scope does
// not care for it
}
pStab++;
}
return( TRUE );
}
else
fprintf(stderr, "No STAB section in the file\n");
return( FALSE );
}
