int DoCompiling(const char *pFileName)
{
int nRet;
char szPath[_MAX_PATH];
FILE *pFile, *pOrigFile;
PSTATEDESC pOrigState;
ObjectType origObject;
PVOID pvTokenContext, pvErrorContext;
if (!s_pContext->m_pLube) {
s_pContext->m_pLube = CreateLube();
if (!s_pContext->m_pLube) {
ErrorReport(Lube_E_OutOfMemory);
return LUBE_FAIL;
}
}
nRet = CreateTemplate(s_pContext->m_pLube, pFileName);
if (nRet < 0) {
ErrorReport(Lube_E_OutOfMemory);
return nRet;
}
if (SearchFileFromPath(s_szCurrentPath, pFileName, szPath) < 0) {
if (SearchFileFromPath(s_pszSourceDirList, pFileName, szPath) < 0) {
ErrorReport(Lube_E_OpenFile, pFileName);
return LUBE_FAIL;
}
}
pFileName = szPath;
CurrentTemplatePath(szPath, s_szCurrentPath);
pFile = fopen(pFileName, "rt");
if (!pFile) {
ErrorReport(Lube_E_OpenFile, pFileName);
return LUBE_FAIL;
}
pvTokenContext = SaveTokenContext();
pvErrorContext = SaveErrorContext();
pOrigState = s_pContext->m_pCurrentState;
origObject = s_pContext->m_curObject;
pOrigFile = s_pContext->m_pFile;
TokenInit();
ErrorReporterInit(pFileName);
s_pContext->m_pCurrentState = \
&s_pContext->m_pLube->ppTemplates[nRet]->tRoot;
s_pContext->m_pFile = pFile;
P_Lube();
s_pContext->m_pFile = pOrigFile;
s_pContext->m_curObject = origObject;
s_pContext->m_pCurrentState = pOrigState;
RestoreErrorContext(pvErrorContext);
RestoreTokenContext(pvTokenContext);
fclose(pFile);
return nRet;
}
// MEMBER -> [ OBJECT s_dot ] <
// k_type | k_name | k_attrib | k_version | k_uuid | k_uunm |
// k_clsid | k_iid | k_value >
//
int P_Member(LubeToken token)
{
ObjectType object;
MemberType member;
PSTATEDESC pDesc;
if (IsObjectToken(token)) {
object = GetObjectType(token);
if (Object_None == object) object = s_pContext->m_curObject;
if (_PeekToken() != Token_S_dot) {
ErrorReport(Lube_E_InvalidMember, g_szCurrentToken);
return Ret_Continue;
}
_GetToken(); // skip s_dot
token = _GetToken();
}
else {
object = s_pContext->m_curObject;
}
member = GetMemberType(object, token);
if (Member_None == member) return Ret_Continue;
pDesc = s_pContext->CreateBlockette(State_Member);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
pDesc->object = object;
pDesc->member = member;
return Ret_Continue;
}
int _tmain(int argc, _TCHAR* argv[])
{
if(argc == 1)
return ErrorReport(L"Please specify a localisation file.");
else if(argc == 2)
return ErrorReport(L"Please specify the name of the array.");
else if(argc == 3)
return ErrorReport(L"Please specify the name of the name-array.");
else if(argc == 4)
return ErrorReport(L"Please specify the counter parameter.");
else if(argc == 5)
return ErrorReport(L"Please specify one or more categories you are looking for.");
tstring file, name, counter_name, id_array_name;
file = argv[1];
name = argv[2];
id_array_name = argv[3];
counter_name = argv[4];
int id = 1;
for(int i = 5 ; i < argc ; ++i)
{
std::vector<tstring> information;
GetHashInfo(argv[i], information);
FillArray(information, name, id_array_name, file, id);
}
tcout << L"set \"" << counter_name << L"=" << (id - 1) << L"\"";
return 0;
}
int ReceiveFileData(int socket)
{
int fd;
int i;
int recv_length = 0;
int write_length = 0;
char buf[MAX_LINE];
// Open the file
fd = open(file_name, O_RDWR | O_CREAT);
if(fd < 0)
{
ErrorReport(FILE_OPEN_ERR);
return FALSE;
}
// Receive file data, one chunck at a time
#if 0
do
{
// Get one chunk of the file from socket
nread = recv(socket, buf, MAX_LINE, 0);
if(nread < 0)
{
ErrorReport(RECEIVE_DATA_ERR);
close(fd);
break;
}
// Write data to file
for(i = 0; i < nread; i += nwrite)
{
nwrite = write(fd, buf + i, nread - i);
}
}while(1);
#endif
do
{
bzero(buf, MAX_LINE);
recv_length = recv(socket, buf, MAX_LINE, 0);
if(FALSE == recv_length)
{
ErrorReport(RECEIVE_DATA_ERR);
return FALSE;
}
for(i = 0; i < recv_length; i += write_length)
{
write_length = write(fd, buf + i, recv_length - i);
if (FALSE == write_length)
{
ErrorReport(FILE_WRITE_ERR);
return FALSE;
}
}
}while(recv_length);
return 0;
}
static
bool Read3dmUserDataHeader( const size_t offset, ON_BinaryArchive& file, ON_TextLog& dump )
{
// TCODE_OPENNURBS_CLASS_USERDATA chunks have 2 uuids
// the first identifies the type of ON_Object class
// the second identifies that kind of user data
ON_UUID userdata_classid = ON_nil_uuid;
ON_UUID userdata_itemid = ON_nil_uuid;
bool rc = file.ReadUuid( userdata_classid );
if ( !rc )
{
ErrorReport(offset,"ReadUuid() failed to read the user data class id.",dump);
}
else
{
dump.Print("UserData class id = ");
dump.Print( userdata_classid );
const ON_ClassId* pUserDataClassId = ON_ClassId::ClassId(userdata_classid);
if ( pUserDataClassId )
{
const char* sClassName = pUserDataClassId->ClassName();
if ( sClassName )
{
dump.Print(" (%s)",sClassName);
}
}
dump.Print("\n");
rc = file.ReadUuid( userdata_itemid );
if ( !rc )
{
ErrorReport(offset,"ReadUuid() failed to read the user data item id.",dump);
}
else
{
dump.Print("UserData item id = ");
dump.Print( userdata_itemid );
dump.Print("\n");
int userdata_copycount = -1;
rc = file.ReadInt( &userdata_copycount );
if ( !rc )
{
ErrorReport(offset,"ReadInt() failed to read the user data copy count.",dump);
}
else
{
ON_Xform userdata_xform;
rc = file.ReadXform( userdata_xform );
if ( !rc )
{
ErrorReport(offset,"ReadXform() failed to read the user data xform.",dump);
}
}
}
}
return rc;
}
void ParseStringToken()
{
int n = 0;
char *s, buf[c_nStrBufSize];
LubeToken token;
ObjectType object;
MemberType member;
s = g_szCurrentToken;
while (*s) {
if (c_nEmbedPrefix != *s) {
buf[n++] = *s++;
}
else {
s++; // skip prefix char
token = *(LubeToken *)s;
s += sizeof(LubeToken); // skip token
if (IsObjectToken(token)) {
if (*s != '.' || *(s + 1) != c_nEmbedPrefix) {
ErrorReport(Lube_E_InvalidEmbed);
return;
}
s += 2;
object = GetObjectType(token);
if (Object_None == object) return;
token = *(LubeToken *)s;
s += sizeof(LubeToken); // skip token
}
else {
object = s_pContext->m_curObject;
}
if (!IsMemberToken(token)) {
ErrorReport(Lube_E_InvalidEmbed);
return;
}
member = GetMemberType(object, token);
if (Member_None == member) return;
buf[n++] = c_nEmbedPrefix;
buf[n++] = (char)object;
buf[n++] = (char)member;
}
}
buf[n] = 0;
strcpy(g_szCurrentToken, buf);
}
// STATEMENT -> TEMPLATE | WITH | IF | FUNC | MEMBER | TEXT
//
int P_Statement()
{
LubeToken token;
token = _GetToken();
switch (token) {
case Token_text:
return CreateTextBlockette();
case Token_K_output:
return P_Output();
case Token_K_template:
return P_Template();
case Token_K_with:
return P_With();
case Token_K_if:
return P_If();
case Token_ident:
return P_Func(g_szCurrentToken, NULL);
case Token_eof:
if (0 != *s_pContext->m_pTextBuffer) CreateTextBlockette();
return Ret_EndOfFile;
case Token_string:
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
return Ret_Continue;
case Token_error:
return Ret_AbortOnError;
default:
return P_Member(token);
}
}
bool __fastcall TForm1::kcFileCheck(AnsiString FileName)
{
//TODO: Add your source code here
if (!FileExists(FileName))
return false;
AnsiString str1,str2;
FILE *fp;
if(fp=fopen(FileName.c_str(),"r")) //rt:r=只读 t=文本模式
str2=fgets(str1.c_str(),4,fp);
fclose(fp);
if(AnsiString(str2)!="01L" && AnsiString(str2)!="01B")
{
ErrorReport(ExtractFileName(FileName),0,"非接驳文件");
//ADOQuery1->SQL->Text="select * from ErrorReport";
//ADOQuery1->Open();
return false;
}
return true;
}
/**
* Find the error report folder and check it matches the app name if provided
*/
FPlatformErrorReport LoadErrorReport()
{
if (ReportDirectoryAbsolutePath.IsEmpty())
{
UE_LOG(CrashReportClientLog, Warning, TEXT("No error report found"));
return FPlatformErrorReport();
}
FPlatformErrorReport ErrorReport(ReportDirectoryAbsolutePath);
FString XMLWerFilename;
ErrorReport.FindFirstReportFileWithExtension( XMLWerFilename, TEXT( ".xml" ) );
extern FCrashDescription& GetCrashDescription();
GetCrashDescription() = FCrashDescription( ReportDirectoryAbsolutePath / XMLWerFilename );
#if CRASH_REPORT_UNATTENDED_ONLY
return ErrorReport;
#else
if( !GameNameFromCmd.IsEmpty() && GameNameFromCmd != GetCrashDescription().GameName )
{
// Don't display or upload anything if it's not the report we expected
ErrorReport = FPlatformErrorReport();
}
return ErrorReport;
#endif
}
/* this function waits for a packet to come back from the file system. If no
* packet is pending, state from the previous packet is returned. This ensures
* that once an error occurs, it state is maintained for the rest of the life
* of the file handle.
*
* This function also deals with IO errors, bringing up the needed DOS
* requesters to let the user retry an operation or cancel it.
*/
LONG
AS_WaitPacket( AsyncFile *file )
{
#ifdef ASIO_NOEXTERNALS
struct ExecBase *SysBase = file->af_SysBase;
struct DosLibrary *DOSBase = file->af_DOSBase;
#endif
LONG bytes;
if( file->af_PacketPending )
{
while( TRUE )
{
/* This enables signalling when a packet comes back to the port */
file->af_PacketPort.mp_Flags = PA_SIGNAL;
/* Wait for the packet to come back, and remove it from the message
* list. Since we know no other packets can come in to the port, we can
* safely use Remove() instead of GetMsg(). If other packets could come in,
* we would have to use GetMsg(), which correctly arbitrates access in such
* a case
*/
Remove( ( struct Node * ) WaitPort( &file->af_PacketPort ) );
/* set the port type back to PA_IGNORE so we won't be bothered with
* spurious signals
*/
file->af_PacketPort.mp_Flags = PA_IGNORE;
/* mark packet as no longer pending since we removed it */
file->af_PacketPending = FALSE;
bytes = file->af_Packet.sp_Pkt.dp_Res1;
if( bytes >= 0 )
{
/* packet didn't report an error, so bye... */
return( bytes );
}
/* see if the user wants to try again... */
if( ErrorReport( file->af_Packet.sp_Pkt.dp_Res2, REPORT_STREAM, file->af_File, NULL ) )
{
return( -1 );
}
/* user wants to try again, resend the packet */
AS_SendPacket( file,
file->af_Buffers[ file->af_ReadMode ?
file->af_CurrentBuf :
1 - file->af_CurrentBuf ] );
}
}
/* last packet's error code, or 0 if packet was never sent */
SetIoErr( file->af_Packet.sp_Pkt.dp_Res2 );
return( file->af_Packet.sp_Pkt.dp_Res1 );
}
// TEMPLATE -> k_template string
//
int P_Template()
{
int nRet;
PSTATEDESC pDesc;
ObjectType object;
pDesc = s_pContext->CreateStatement(State_Template);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
if (_GetToken() != Token_string) {
ErrorReport(Lube_E_ExpectSymbol, "template name");
return Ret_AbortOnError;
}
nRet = FindTemplate(s_pContext->m_pLube, g_szCurrentToken);
if (nRet < 0) {
nRet = DoCompiling(g_szCurrentToken);
}
if (nRet >= 0) {
pDesc->dwExtra = nRet;
object = s_pContext->m_pLube->ppTemplates[nRet]->tRoot.object;
if (Object_Class == object) {
if (s_pContext->m_nClass > 0) {
pDesc->object = Object_Class;
}
else {
ErrorReport(Lube_E_NoValidObject, "class");
}
}
else if (Object_Interface == object) {
if (s_pContext->m_nInterface > 0) {
pDesc->object = Object_Interface;
}
else {
ErrorReport(Lube_E_NoValidObject, "interface");
}
}
}
s_pContext->LeaveStatement();
return Ret_Continue;
}
// OUTPUT -> k_output string { STATEMENT } k_end k_output
//
int P_Output()
{
int nRet;
PSTATEDESC pDesc;
pDesc = s_pContext->CreateStatement(State_Output);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
if (_GetToken() != Token_string) {
ErrorReport(Lube_E_ExpectSymbol, "output file name");
return Ret_AbortOnError;
}
pDesc->uDataSize = strlen(g_szCurrentToken) + 1;
pDesc->pvData = new char[pDesc->uDataSize];
if (!pDesc->pvData) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
strcpy((char *)pDesc->pvData, g_szCurrentToken);
while (_PeekToken() != Token_K_end) {
nRet = P_Statement();
if (Ret_EndOfFile == nRet) {
ErrorReport(Lube_E_UnexpectEOF);
return Ret_AbortOnError;
}
if (Ret_Continue != nRet) return nRet;
}
_GetToken(); // skip k_end
if (_GetToken() != Token_K_output) {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
}
s_pContext->LeaveStatement();
return Ret_Continue;
}
// LUBE -> INPUT { STATMENT }
// INPUT -> k_input < k_module | k_class | k_interface >
//
int P_Lube()
{
int nRet;
LubeToken token;
if (_GetToken() != Token_K_input) {
ErrorReport(Lube_E_ExpectSymbol, "input");
return Ret_AbortOnError;
}
switch (token = _GetToken()) {
case Token_K_module:
s_pContext->m_curObject = Object_Module;
break;
case Token_K_class:
s_pContext->m_curObject = Object_Class;
s_pContext->m_nClass++;
break;
case Token_K_interface:
s_pContext->m_curObject = Object_Interface;
s_pContext->m_nInterface++;
break;
default:
ErrorReport(Lube_E_InvalidInput, g_szCurrentToken);
case Token_error:
return Ret_AbortOnError;
}
s_pContext->m_pCurrentState->object = s_pContext->m_curObject;
while ((nRet = P_Statement()) == Ret_Continue);
if (Token_K_class == token) {
s_pContext->m_nClass--;
}
else if (Token_K_interface == token) {
s_pContext->m_nInterface--;
}
return nRet;
}
void CreateError(int r, const char *pszType, const char *pszName)
{
switch (r) {
case CLSError_DupEntry:
ErrorReport(CAR_E_DupEntry, pszType, pszName);
break;
case CLSError_FullEntry:
ErrorReport(CAR_E_FullEntry, pszType);
break;
case CLSError_OutOfMemory:
ErrorReport(CAR_E_OutOfMemory);
break;
case CLSError_NameConflict:
ErrorReport(CAR_E_NameConflict, pszType, pszName);
break;
default:
assert(TRUE == FALSE);
break;
}
}
void fstk_RunString (char *s)
{
struct sSymbol *pSym;
if ((pSym=sym_FindSymbol(s))!=NULL)
{
pushcontext ();
nCurrentStatus = STAT_isMacroArg;
strcpy (tzCurrentFileName, s);
CurrentFlexHandle = yy_scan_bytes (pSym->pMacro, strlen (pSym->pMacro));
yy_switch_to_buffer (CurrentFlexHandle);
}
else
{
ErrorReport ("No such string symbol");
}
}
// FUNC -> ident s_lparen [ MEMBER | OBJECT | string ] s_rparen
//
int P_Func(const char *pszFunc, PSTATEDESC pDesc)
{
int nIndex, nRet;
LubeToken token;
if (_PeekToken() != Token_S_lparen) {
ErrorReport(Lube_E_UnexpectSymbol, pszFunc);
return Ret_Continue;
}
nIndex = GetUserFuncIndex(pszFunc);
if (nIndex < 0) {
ErrorReport(Lube_E_UndefFunc, pszFunc);
return Ret_AbortOnError;
}
_GetToken(); // skip s_lparen
if (NULL == pDesc) {
pDesc = s_pContext->CreateBlockette(State_Func);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
}
pDesc->dwExtra = (DWORD)nIndex;
token = _GetToken();
if (Token_string == token) {
pDesc->uDataSize = strlen(g_szCurrentToken) + 1;
pDesc->pvData = new char[pDesc->uDataSize];
if (!pDesc->pvData) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
strcpy((char *)pDesc->pvData, g_szCurrentToken);
token = _GetToken();
}
else if (IsKeywordToken(token)) {
nRet = GetMemberObject(token, pDesc);
if (Ret_Continue != nRet) return nRet;
token = _GetToken();
}
if (CheckUserFuncArg(nIndex, pDesc) < 0) {
ErrorReport(Lube_E_InvalidFuncArg);
}
if (Token_S_rparen != token) {
ErrorReport(Lube_E_ExpectSymbol, ")");
}
return Ret_Continue;
}
std::vector<Value*> Method::emit_call_to(SourceRange loc, Method & callee, ArrayRef<Value*> inputs) {
ensureTensors(loc, inputs);
JIT_ASSERT(!executor);
try {
callee.ensure_defined();
} catch (RecursiveMethodCallError&) {
throw ErrorReport(loc) << " method '" << callee.name()
<< "' is called recursively involving this call site. Recursive calls are not supported";
}
auto fn = callee.graph();
ensureSizeMatches(loc, callee.num_inputs(), inputs.size(), "inputs");
std::vector<Value*> all_inputs = inputs;
// parameters to callee method (which become parameters to _this_ method
// if they were not already)
for(at::Tensor* member : callee.member_inputs) {
all_inputs.push_back(get_or_add_parameter(member));
}
return inlineCallTo(*graph(), *callee.graph(), all_inputs);
}
int CreateTextBlockette()
{
int size;
char *pszText = NULL;
PSTATEDESC pDesc = NULL;
size = strlen(s_pContext->m_pTextBuffer) + 1;
pszText = new char[size];
if (!pszText) goto ErrorExit;
pDesc = s_pContext->CreateBlockette(State_Text);
if (!pDesc) goto ErrorExit;
strcpy(pszText, s_pContext->m_pTextBuffer);
*(s_pContext->m_pTextBuffer) = 0;
pDesc->uDataSize = size;
pDesc->pvData = (PVOID)pszText;
return Ret_Continue;
ErrorExit:
if (pszText) delete [] pszText;
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
BOOL CFCView::GetSysChar()
{
switch(m_source[m_iCharCount])
{
case '0':
m_iCharCount++;
m_char='\0';
return TRUE;
case 'n':
m_iCharCount++;
m_char='\n';
return TRUE;
case 't':
m_iCharCount++;
m_char='\t';
return TRUE;
case '\'':
m_iCharCount++;
m_char='\'';
return TRUE;
case '\"':
m_iCharCount++;
m_char='\"';
return TRUE;
case '\\':
m_iCharCount++;
m_char='\\';
return TRUE;
default:
if(!ErrorReport(ET_UNKNOWNSYSCHAR))
return FALSE;
m_char=m_source[m_iCharCount];
m_iCharCount++;
return TRUE;
}
}
int GetMemberObject(LubeToken token, PSTATEDESC pDesc)
{
if (IsObjectToken(token)) {
pDesc->object = GetObjectType(token);
if (Object_None == pDesc->object) {
pDesc->object = s_pContext->m_curObject;
}
if (Object_LubeOption == pDesc->object) {
pDesc->member = Member_Name;
return Ret_Continue;
}
if (Object_CompilingEnv== pDesc->object) {
pDesc->member = Member_Name;
return Ret_Continue;
}
if (Object_InuptType== pDesc->object) {
pDesc->member = Member_Name;
return Ret_Continue;
}
if (_PeekToken() != Token_S_dot) return Ret_Continue;
_GetToken(); // skip s_dot
token = _GetToken();
}
else {
pDesc->object = s_pContext->m_curObject;
}
if (IsMemberToken(token)) {
pDesc->member = GetMemberType(pDesc->object, token);
}
else {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
}
return Ret_Continue;
}
/*-------------------------------------------------------------------------
* Function : VerifyFlash
* Function to Read Hex file and verify flash with contents
* Input :
* Output :
* Return : None
* ----------------------------------------------------------------------*/
BOOL VerifyFlash( void )
{
ST_ErrorCode_t ErrCode = ST_NO_ERROR;
int Section, Bank ;
U32 Length;
U32 ReadOffset;
U32 NumberOfBytes;
U8 *Buffer_p;
BOOL VerifyFailed;
int ErrorCount = 0;
/* check data size */
if ( FlashSize == 0 )
{
VerifyFailed = TRUE;
}
else
{
VerifyFailed = FALSE;
STFLASH_Print(("\t\t+------------+------------+\n"));
}
/* Find out which blocks are to be verified */
/* Read the data and compare */
for ( Section = 0; ( Section < NUM_SECTIONS ) && ( VerifyFailed == FALSE ); Section ++ )
{
if ( SectionInfo[Section].Block != 0xFF )
{
Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
Length = BlockInfo[ SectionInfo[Section].Block ].Length;
ReadOffset = SectionInfo[Section].Address - BaseAddress[Bank];
/* allocate temp buffer to put flash data in */
Buffer_p = memory_allocate( system_partition, Length );
if ( Buffer_p != NULL )
{
STFLASH_Print(("block %2d\t| 0x%08x | 0x%08x | ",
SectionInfo[Section].Block,
SectionInfo[Section].Address,
SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
ErrCode = STFLASH_Read( FLASHHndl[Bank],
ReadOffset,
Buffer_p,
SectionInfo[Section].Size,
&NumberOfBytes );
if (ErrCode != ST_NO_ERROR)
{
ErrorReport(&ErrorCount, ErrCode, ST_NO_ERROR);
}
if ( memcmp( Buffer_p,(U8*)&FlashData_p[SectionInfo[Section].Offset],
SectionInfo[Section].Size ) != 0 )
{
STFLASH_Print(("Verify FAILED\n"));
VerifyFailed = TRUE;
}
else
{
STFLASH_Print(("VERIFIED\n"));
}
/* deallocate temp buffer */
memory_deallocate( system_partition, Buffer_p );
}
}
}
if ( FlashData_p != NULL )
{
memory_deallocate( system_partition, FlashData_p );
}
if ( VerifyFailed == TRUE )
{
STFLASH_Print(("!!!! VERIFY Failed !!!!\n"));
return TRUE;
}
else
{
STFLASH_Print(("\t\t+------------+------------+\n"));
return FALSE;
}
} /* end VerifyFlash */
ObjectType GetConditionObjectType(LubeToken token)
{
if (!IsObjectToken(token)) {
ErrorReport(Lube_E_InvalidWithObj, g_szCurrentToken);
return s_pContext->m_curObject;
}
switch (token) {
case Token_K_library:
return Object_Library;
case Token_K_class:
return Object_Class;
case Token_K_super:
return Object_Super;
case Token_K_interface:
if (0 != s_pContext->m_nClass) return Object_ClsIntf;
return Object_Interface;
case Token_K_struct:
return Object_Struct;
case Token_K_enum:
return Object_Enum;
case Token_K_const:
return Object_Const;
case Token_K_typedef:
return Object_Typedef;
case Token_K_interfaceconst:
if (0 == s_pContext->m_nInterface) {
ErrorReport(Lube_E_NoValidObject, "interfaceconst");
return Object_None;
}
return Object_IntfConst;
case Token_K_method:
if (Object_Class == s_pContext->m_curObject) {
return Object_ClassMethod;
}
else if (0 != s_pContext->m_nInterface) {
return Object_IntfMethod;
}
ErrorReport(Lube_E_NoValidObject, "interface");
return Object_None;
case Token_K_constructor:
return Object_ClassConstructor;
case Token_K_coalescence:
return Object_CbCoalescence;
case Token_K_parameter:
if (0 == s_pContext->m_nClassMethod
&& 0 == s_pContext->m_nIntfMethod) {
ErrorReport(Lube_E_NoValidObject, "method");
return Object_None;
}
return Object_Param;
case Token_K_member:
if (Object_Struct == s_pContext->m_curObject) {
return Object_StcMember;
}
else if (Object_Enum == s_pContext->m_curObject) {
return Object_EnumMember;
}
ErrorReport(Lube_E_NoValidObject, "member");
return Object_None;
case Token_K_aspect:
if (0 == s_pContext->m_nClass) {
ErrorReport(Lube_E_NoValidObject, "class");
return Object_None;
}
return Object_Aspect;
case Token_K_aggregate:
if (0 == s_pContext->m_nClass) {
ErrorReport(Lube_E_NoValidObject, "class");
return Object_None;
}
return Object_Aggregate;
case Token_K_classforaspect:
if (0 == s_pContext->m_nClass) {
ErrorReport(Lube_E_NoValidObject, "classforaspect");
return Object_None;
}
return Object_ClassForAspect;
case Token_K_parent:
if (0 == s_pContext->m_nInterface) {
ErrorReport(Lube_E_NoValidObject, "parent");
return Object_None;
}
return Object_Parent;
case Token_K_child:
if (0 == s_pContext->m_nInterface) {
ErrorReport(Lube_E_NoValidObject, "child");
return Object_None;
}
return Object_Child;
case Token_K_parents_and_me:
if (Object_ClsIntf == s_pContext->m_curObject) {
return Object_ClsIntfAndParents;
}
ErrorReport(Lube_E_NoValidObject, "parents_and_me");
return Object_None;
default:
ErrorReport(Lube_E_InvalidWithObj, g_szCurrentToken);
return Object_None;
}
}
// IF -> k_if CONDITION { < k_and | k_or > CONDITION } { STATEMENT }
// [ k_else { STATEMENT } ] k_end k_if
//
int P_If()
{
BOOL bElse = FALSE;
int nRet;
LubeToken token;
PSTATEDESC pDesc, pNextDesc;
pDesc = s_pContext->CreateStatement(State_If);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
pDesc = s_pContext->CreateBlockette(State_Condition);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
nRet = P_Condition(pDesc);
if (nRet != Ret_Continue) return nRet;
token = _PeekToken();
while (Token_K_and == token || Token_K_or == token) {
token = _GetToken(); // skip k_and or k_or
pNextDesc = s_pContext->CreateBlockette(State_Condition);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
nRet = P_Condition(pNextDesc);
if (nRet != Ret_Continue) return nRet;
pDesc->dwCondition |= (Token_K_and == token ?
Condition_And:Condition_Or);
pDesc = pNextDesc;
token = _PeekToken();
}
while (token != Token_K_end) {
if (Token_K_else == token) {
if (bElse) {
ErrorReport(Lube_E_MultiElse);
}
else {
pDesc = s_pContext->CreateBlockette(State_Else);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory);
return Ret_AbortOnError;
}
bElse = TRUE;
}
_GetToken(); // skip k_else
}
else {
nRet = P_Statement();
if (Ret_EndOfFile == nRet) {
ErrorReport(Lube_E_UnexpectEOF);
return Ret_AbortOnError;
}
if (Ret_Continue != nRet) return nRet;
}
token = _PeekToken();
}
_GetToken(); // skip k_end
if (_GetToken() != Token_K_if) {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
}
s_pContext->LeaveStatement(); // leave if statement
return Ret_Continue;
}
// CONDITION -> OBJCOND | MEMCOND | FUNCOND
// MEMCOND -> MEMBER k_is [ k_not ] string
// OBJCOND -> OBJECT k_is [ k_not ] < k_first | k_last >
// FUNCOND -> FUNC k_is [ k_not ] < k_true | k_false >
//
int P_Condition(PSTATEDESC pDesc)
{
LubeToken token;
int nRet;
token = _GetToken();
if (Token_ident == token) {
nRet = P_Func(g_szCurrentToken, pDesc);
if (Ret_Continue != nRet) return nRet;
pDesc->dwCondition |= Condition_Function;
}
else {
nRet = GetMemberObject(token, pDesc);
if (Ret_Continue != nRet) return nRet;
}
if (Token_K_is != _GetToken()) {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
return Ret_AbortOnError;
}
token = _GetToken();
if (Token_K_not == token) {
pDesc->dwCondition |= Condition_Not;
token = _GetToken();
}
if (Condition_Function & pDesc->dwCondition) {
switch (token) {
case Token_K_true:
pDesc->dwCondition |= Condition_True;
break;
case Token_K_false:
pDesc->dwCondition |= Condition_False;
break;
default:
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
case Token_error:
return Ret_AbortOnError;
}
return Ret_Continue;
}
else if (Member_None == pDesc->member) {
switch (token) {
case Token_K_first:
pDesc->dwCondition |= Condition_First;
break;
case Token_K_last:
pDesc->dwCondition |= Condition_Last;
break;
default:
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
case Token_error:
return Ret_AbortOnError;
}
if (Object_Module == pDesc->object
|| Object_Parent == pDesc->object) {
ErrorReport(Lube_E_HasNoOrder);
}
return Ret_Continue;
}
else if (Token_string != token) {
if (Token_error != token) {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
}
return Ret_AbortOnError;
}
return CheckMemberCondition(pDesc, g_szCurrentToken);
}
// WITH -> k_with [ k_all | k_first | k_last ]
// OBJECT k_do { STATEMENT } k_end k_do
//
int P_With()
{
StatementType type;
LubeToken token;
PSTATEDESC pDesc;
ObjectType origObject = Object_None;
DWORD dwCondition = 0;
int nRet;
token = _GetToken();
if (Token_K_all == token) {
type = State_WithAll;
token = _GetToken();
}
else {
if (Token_K_first == token) {
dwCondition = Condition_First;
token = _GetToken();
}
else if (Token_K_last == token) {
dwCondition = Condition_Last;
token = _GetToken();
}
type = State_With;
}
pDesc = s_pContext->CreateStatement(type);
if (!pDesc) {
ErrorReport(Lube_E_OutOfMemory, g_szCurrentToken);
return Ret_AbortOnError;
}
pDesc->dwCondition = dwCondition;
if (type == State_WithAll || 0 != dwCondition) {
pDesc->object = GetConditionObjectType(token);
}
else {
pDesc->object = GetObjectType(token);
}
if (Object_None != pDesc->object) {
origObject = s_pContext->EnterObject(pDesc->object);
}
if (_GetToken() != Token_K_do) {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
return Ret_AbortOnError;
}
while (_PeekToken() != Token_K_end) {
nRet = P_Statement();
if (Ret_EndOfFile == nRet) {
ErrorReport(Lube_E_UnexpectEOF);
return Ret_AbortOnError;
}
if (Ret_Continue != nRet) return nRet;
}
_GetToken(); // skip k_end
if (_GetToken() != Token_K_do) {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
}
s_pContext->LeaveStatement(); // leave with statement
if (pDesc->object != Object_None) {
s_pContext->LeaveObject(origObject);
}
return Ret_Continue;
}
int main( int argc, char **argv )
//*******************************
{
static char *fname;
#ifndef __WATCOMC__
_argv = argv;
_argc = argc;
#endif
MemInit();
if( !AsMsgInit() ) {
return( EXIT_FAILURE );
}
if( argc == 1 ) {
Banner();
Usage();
} else if( OptionsInit( --argc, ++argv ) ) {
Banner();
if( _IsOption( PRINT_HELP ) ) {
Usage();
*argv = NULL;
} else if( !*argv ) {
AsOutMessage( stderr, AS_MSG_ERROR );
AsOutMessage( stderr, NO_FILENAME_SPECIFIED );
fputc( '\n', stderr );
}
while( *argv ) {
fname = MakeAsmFilename( *argv );
if( PP_Init( fname, PPFLAG_ASM_COMMENT | PPFLAG_EMIT_LINE, NULL ) != 0 ) {
AsOutMessage( stderr, UNABLE_TO_OPEN, fname );
fputc( '\n', stderr );
} else {
OptionsPPDefine();
SymInit();
InsInit();
DirInit();
if( ObjInit( fname ) ) {
if( setjmp( AsmParse ) == 0 ) {
ErrorCountsReset();
DoReport = TRUE;
if( !yyparse() ) {
CurrLineno--; // This is the total # of lines
ObjRelocsFini(); // Must be done before ErrorReport
// and other finis
} else {
DoReport = FALSE;
}
} else { // AbortParse() was invoked
DoReport = FALSE;
}
ErrorReport();
AsLexerFini();
ObjFini();
}
DirFini();
InsFini();
SymFini();
}
PP_Fini();
++argv;
}
}
OptionsFini();
AsMsgFini();
MemFini();
return( ExitStatus );
}
ObjectType GetObjectType(LubeToken token)
{
if (!IsObjectToken(token)) {
ErrorReport(Lube_E_InvalidWithObj, g_szCurrentToken);
return s_pContext->m_curObject;
}
switch (token) {
case Token_K_module:
return Object_Module;
case Token_K_library:
if (0 == s_pContext->m_nLibrary) {
ErrorReport(Lube_E_NoValidObject, "library");
return Object_None;
}
return Object_Library;
case Token_K_class:
if (0 == s_pContext->m_nClass) {
ErrorReport(Lube_E_NoValidObject, "class");
return Object_None;
}
return Object_Class;
case Token_K_interface:
if (0 != s_pContext->m_nClass) {
return Object_ClsIntf;
}
if (0 == s_pContext->m_nInterface) {
ErrorReport(Lube_E_NoValidObject, "interface");
return Object_None;
}
return Object_Interface;
case Token_K_struct:
if (0 == s_pContext->m_nStruct) {
ErrorReport(Lube_E_NoValidObject, "struct");
return Object_None;
}
return Object_Struct;
case Token_K_enum:
if (0 == s_pContext->m_nEnum) {
ErrorReport(Lube_E_NoValidObject, "enum");
return Object_None;
}
return Object_Enum;
case Token_K_const:
if (0 == s_pContext->m_nConst) {
ErrorReport(Lube_E_NoValidObject, "const");
return Object_None;
}
return Object_Const;
case Token_K_typedef:
if (0 == s_pContext->m_nTypedef) {
ErrorReport(Lube_E_NoValidObject, "typedef");
return Object_None;
}
return Object_Typedef;
case Token_K_interfaceconst:
if (0 == s_pContext->m_nIntfConst) {
ErrorReport(Lube_E_NoValidObject, "interfaceconst");
return Object_None;
}
return Object_IntfConst;
case Token_K_method:
if (0 != s_pContext->m_nIntfMethod) {
return Object_IntfMethod;
}
else if (0 != s_pContext->m_nClassMethod) {
return Object_ClassMethod;
}
ErrorReport(Lube_E_NoValidObject, "method");
return Object_None;
case Token_K_coalescence:
return Object_CbCoalescence;
case Token_K_parameter:
if (0 == s_pContext->m_nParameter) {
ErrorReport(Lube_E_NoValidObject, "parameter");
return Object_None;
}
return Object_Param;
case Token_K_aspect:
if (0 == s_pContext->m_nAspect) {
ErrorReport(Lube_E_NoValidObject, "aspect");
return Object_None;
}
return Object_Aspect;
case Token_K_aggregate:
if (0 == s_pContext->m_nAggregate) {
ErrorReport(Lube_E_NoValidObject, "aggregate");
return Object_None;
}
return Object_Aggregate;
case Token_K_classforaspect:
if (0 == s_pContext->m_nForClass) {
ErrorReport(Lube_E_NoValidObject, "classforaspect");
return Object_None;
}
return Object_ClassForAspect;
case Token_K_member:
if (Object_Struct == s_pContext->m_curObject) {
if (0 != s_pContext->m_nStructMember) {
return Object_StcMember;
}
}
else if (Object_Enum == s_pContext->m_curObject) {
if (0 != s_pContext->m_nEnumMember) {
return Object_EnumMember;
}
}
ErrorReport(Lube_E_NoValidObject, "struct or enum member");
return Object_None;
case Token_K_super:
if (0 == s_pContext->m_nClass) {
ErrorReport(Lube_E_NoValidObject, "super");
return Object_None;
}
return Object_Super;
case Token_K_parent:
if (0 == s_pContext->m_nInterface) {
ErrorReport(Lube_E_NoValidObject, "parent");
return Object_None;
}
return Object_Parent;
case Token_K_child:
if (0 == s_pContext->m_nInterface) {
ErrorReport(Lube_E_NoValidObject, "child");
return Object_None;
}
return Object_Child;
case Token_K_parents_and_me:
if (Object_ClsIntf == s_pContext->m_curObject) {
return Object_ClsIntfAndParents;
}
ErrorReport(Lube_E_NoValidObject, "parents_and_me");
return Object_None;
case Token_K_lubeoption:
return Object_LubeOption;
case Token_K_compilingenv:
return Object_CompilingEnv;
case Token_K_inputtype:
return Object_InuptType;
default:
ErrorReport(Lube_E_InvalidWithObj, g_szCurrentToken);
return Object_None;
}
}
int BootFromFlash( void )
{
long int HexFile_p = 0; /* datafile descriptor */
long int HexFileSize = 0; /* size in bytes of the file */
int ErrorCount = 0;
ST_ErrorCode_t ReturnError = ST_NO_ERROR;
char Filename[] = "flash.hex";
U8 Block;
U32 BlockStart;
STFLASH_Print(( "\n" ));
STFLASH_Print(( "============================================================\n" ));
STFLASH_Print(( "Commencing Boot From Flash Test ..\n" ));
STFLASH_Print(( "============================================================\n" ));
/* Init Bank 0, Vpp 0 */
InitParams_s.DeviceType = DEVICE_TYPE;
InitParams_s.BaseAddress = (U32*)STFLASH_BANK_0_BASE;
InitParams_s.VppAddress = (U32*)STFLASH_VPP_0_ENABLE;
InitParams_s.MinAccessWidth = MIN_ACCESS_WIDTH;
InitParams_s.MaxAccessWidth = MAX_ACCESS_WIDTH;
InitParams_s.NumberOfBlocks = NUM_BLOCKS;
InitParams_s.Blocks = BlockData_s;
#ifdef ST_OS21
InitParams_s.DriverPartition = system_partition;
#else
InitParams_s.DriverPartition = TEST_PARTITION_1;
#endif
STFLASH_Print(( "FLASH_BANK_0_BASE = %x\n", STFLASH_BANK_0_BASE ));
STFLASH_Print(( "Calling STFLASH_Init() Bank0 ..........\n" ));
ReturnError = STFLASH_Init( "Bank0", &InitParams_s );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
/* Open Bank 0 */
STFLASH_Print(( "Calling STFLASH_Open() Bank0 ..........\n" ));
ReturnError = STFLASH_Open( "Bank0",
&OpenParams_s,
&FLASHHndl[0] );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
/* GetParams for Bank 0 */
GetParams_s.InitParams.Blocks = GetBlkDat_s;
STFLASH_Print(( "Calling STFLASH_GetParams() Bank 0 ....\n" ));
ReturnError = STFLASH_GetParams( FLASHHndl[0], &GetParams_s );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
ParamsReport( &GetParams_s );
BlockStart = BaseAddress[BANK0] = (U32) InitParams_s.BaseAddress;
for ( Block = 0; Block < InitParams_s.NumberOfBlocks; Block ++)
{
BlockInfo[Block].Bank = 0;
BlockInfo[Block].Address = BlockStart;
BlockInfo[Block].Length = InitParams_s.Blocks[Block].Length;
BlockStart += InitParams_s.Blocks[Block].Length;
}
/* Open and Read file into memory */
HexFile_p = debugopen(Filename, "rb");
STFLASH_Print(("HexFile_p = 0x%8x\n",HexFile_p));
if (HexFile_p < 0)
{
STFLASH_Print(("Error opening file \'%s\'\n", Filename ));
return (0);
}
else
{
HexFileSize = debugfilesize(HexFile_p);
STFLASH_Print(("HexFileSize = 0x%8x\n",HexFileSize));
/* allocate File data buffer */
FlashData_p = (char*) memory_allocate( system_partition, (U32) HexFileSize );
if ( FlashData_p != NULL )
{
STFLASH_Print(("Loading \'%s\' into memory, wait .. ", Filename ));
debugread(HexFile_p, FlashData_p, (size_t) HexFileSize);
STFLASH_Print(("%d bytes\n", HexFileSize ));
}
else
{
STFLASH_Print(("Not enough memory for HEX file (%d bytes)\n", HexFileSize));
HexFileSize = 0;
}
debugclose(HexFile_p);
}
if ( HexFileSize > 0 )
{
/* convert buffer to binary and resize memory */
STFLASH_Print(("Converting file in memory, wait .. "));
FlashSize = ConvertMemory( HexFileSize );
if ( FlashSize > 0 )
{
STFLASH_Print(("%d bytes\n", FlashSize ));
FlashData_p = (char*) memory_reallocate( system_partition, FlashData_p, FlashSize );
}
else
{
STFLASH_Print(("Invalid file\n"));
}
}
if ( EraseFlash(FALSE) == FALSE )
{
if ( ProgramFlash() == FALSE )
{
VerifyFlash();
}
}
/* Close Bank 0 */
STFLASH_Print(( "Calling STFLASH_Close() Bank 0 ........\n" ));
ReturnError = STFLASH_Close( FLASHHndl[0] );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
/* Term Bank 0 */
TermParams_s.ForceTerminate = FALSE;
STFLASH_Print(( "Calling STFLASH_Term() Bank 0 .........\n" ));
ReturnError = STFLASH_Term( "Bank0", &TermParams_s );
ErrorReport( &ErrorCount, ReturnError, ST_NO_ERROR );
return( ErrorCount );
}
static void IntActUse( void )
{
long int RetValue;
char KeyBuff;
U8 KeyCode;
BOOL Running = TRUE;
BOOL GlitchAct = FALSE;
ST_ErrorCode_t StoredError = ST_NO_ERROR;
ST_ErrorCode_t ReturnError;
U32 PCRFrequency = CLK_FREQUENCY;
U32 STCFrequency;
U32 MarkValue;
BOOL JumpInPCR = FALSE;
U32 BaseB32 = 0;
U32 PCRBase;
U32 PCRExtd;
U32 STCBase;
U32 STCExtd;
clock_t CurrTime, PrevTime, ElapTime;
clock_t PCRTicks, STCTicks;
STTBX_Print(( "\nHarness Software Revision is %s\n\n", HarnessRev ));
STTBX_Print(( "==========================================================\n" ));
STTBX_Print(( "Commencing IntActUse Test Function for Legacy PTI....\n" ));
STTBX_Print(( "==========================================================\n" ));
STCTicks = time_now();
/* Initialize the sub-subordinate PIO Driver
for Port1 only (PWM access enable) */
/* Initialize the sub-subordinate PIO Driver
for Port1 only (PWM access enable) */
#if defined (ST_5514) || defined (ST_5516) || defined (ST_5517)
/* for Port2 only (PWM access enable) */
strcpy( PIODevNam, "Port2" );
PIOInitPars_s.BaseAddress = (U32*)PIO_2_BASE_ADDRESS;
PIOInitPars_s.InterruptNumber = PIO_2_INTERRUPT;
PIOInitPars_s.InterruptLevel = PIO_2_INTERRUPT_LEVEL;
#else
/* for Port1 only (PWM access enable) */
strcpy( PIODevNam, "Port1" );
PIOInitPars_s.BaseAddress = (U32*)PIO_1_BASE_ADDRESS;
PIOInitPars_s.InterruptNumber = PIO_1_INTERRUPT;
PIOInitPars_s.InterruptLevel = PIO_1_INTERRUPT_LEVEL;
#endif
PIOInitPars_s.DriverPartition = TEST_PARTITION_1;
STTBX_Print(( "Calling STPIO_Init() ................\n" ));
ReturnError = STPIO_Init( PIODevNam, &PIOInitPars_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Initialize the sub-ordinate PWM Driver
for Channel 0 only (VCXO fine control) */
strcpy( PWMDevNam, "STPWM" );
PWMInitPars_s.Device = STPWM_C4;
PWMInitPars_s.C4.BaseAddress = (U32*)PWM_BASE_ADDRESS;
PWMInitPars_s.C4.PrescaleFactor = STPWM_PRESCALE_MIN;
strcpy( PWMInitPars_s.C4.PIOforPWM0.PortName, PIODevNam );
#if defined (ST_5514) || defined (ST_5516) || defined (ST_5517)
PWMInitPars_s.C4.PIOforPWM0.BitMask = PIO_BIT_7;
#else
PWMInitPars_s.C4.PIOforPWM0.BitMask = PIO_BIT_3;
#endif
PWMInitPars_s.C4.PIOforPWM1.PortName[0] = '\0';
PWMInitPars_s.C4.PIOforPWM1.BitMask = 0;
PWMInitPars_s.C4.PIOforPWM2.PortName[0] = '\0';
PWMInitPars_s.C4.PIOforPWM2.BitMask = 0;
STTBX_Print(( "Calling STPWM_Init() for VCXO Channel\n" ));
ReturnError = STPWM_Init( PWMDevNam, &PWMInitPars_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Initialize the sub-ordinate EVT Driver */
strcpy( EVTDevNam, "STEVT" );
EVTInitPars_s.EventMaxNum = 3;
EVTInitPars_s.ConnectMaxNum = 2;
EVTInitPars_s.SubscrMaxNum = 9; /*3; modified for new bom */
EVTInitPars_s.MemoryPartition = TEST_PARTITION_2;
EVTInitPars_s.MemorySizeFlag = STEVT_UNKNOWN_SIZE;
STTBX_Print(( "Calling STEVT_Init()\n" ));
ReturnError = STEVT_Init( EVTDevNam, &EVTInitPars_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Call STEVT_Open() so that we can subscribe to events */
STTBX_Print(( "Calling STEVT_Open() ................\n" ));
ReturnError = STEVT_Open( EVTDevNam, &EVTOpenPars_s, &EVTHandle );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Subscribe to PCR Events now so that we can get
callbacks when events are registered */
STTBX_Print(( "Calling STEVT_Subscribe(STCLKRV_PCR_VALID_EVT) .....\n" ));
ReturnError = STEVT_Subscribe( EVTHandle, STCLKRV_PCR_VALID_EVT,
&EVTSubscrParams );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
STTBX_Print(( "Calling STEVT_Subscribe(STCLKRV_PCR_DISCONTINUITY_EVT) ...\n" ));
ReturnError = STEVT_Subscribe( EVTHandle, STCLKRV_PCR_DISCONTINUITY_EVT,
&EVTSubscrParams );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
STTBX_Print(( "Calling STEVT_Subscribe(STCLKRV_PCR_GLITCH_EVT) ....\n" ));
ReturnError = STEVT_Subscribe( EVTHandle, STCLKRV_PCR_GLITCH_EVT,
&EVTSubscrParams );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Initialize our native Clock Recovery Driver */
strcpy( DeviceNam, "STCLKRV" );
strcpy( InitParams_s.PWMDeviceName, PWMDevNam );
InitParams_s.VCXOChannel = STCLKRVT_VCXO_CHANNEL;
InitParams_s.InitialMark = STCLKRV_INIT_MARK_VALUE;
InitParams_s.MinimumMark = STCLKRV_MIN_MARK_VALUE;
InitParams_s.MaximumMark = STCLKRV_MAX_MARK_VALUE;
InitParams_s.PCRMaxGlitch = STCLKRV_PCR_MAX_GLITCH;
InitParams_s.PCRDriftThres = STCLKRV_PCR_DRIFT_THRES;
InitParams_s.TicksPerMark = STCLKRV_TICKS_PER_MARK;
InitParams_s.MinSampleThres = STCLKRV_MIN_SAMPLE_THRESHOLD;
InitParams_s.MaxWindowSize = STCLKRV_MAX_WINDOW_SIZE;
InitParams_s.Partition_p = TEST_PARTITION_2;
InitParams_s.DeviceType = STCLKRV_DEVICE_PWMOUT;
strcpy( InitParams_s.EVTDeviceName, EVTDevNam );
STTBX_Print(( "Calling STCLKRV_Init() ..............\n" ));
ReturnError = STCLKRV_Init( DeviceNam, &InitParams_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Open the Clock Recovery Driver */
STTBX_Print(( "Calling STCLKRV_Open() ..............\n" ));
ReturnError = STCLKRV_Open( DeviceNam, &OpenParams_s, &Handle );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
PCRTicks = CurrTime = time_now();
STTBX_Print(( "==========================================================\n" ));
STTBX_Print(( "Keys are as follows (case insensitive apart from U & D):\n" ));
STTBX_Print(( "U - Up PCR frequency D - Down PCR frequency\n" ));
STTBX_Print(( "E - Expected PCR jump J - Jump in PCR (unexpected)\n" ));
STTBX_Print(( "G - Glitch in PCR clock Q - Quit InterActive Test\n" ));
STTBX_Print(( "==========================================================\n" ));
while( Running )
{
ReturnError = STCLKRV_PwmGetRatio( Handle, &MarkValue );
STCFrequency = CLK_FREQUENCY + ( STCLKRV_TICKS_PER_MARK *
( MarkValue - STCLKRV_INIT_MARK_VALUE ) );
STTBX_Print(( "PCR = %dHz\tSTC = %dHz\tPWM = %3d\t",
PCRFrequency, STCFrequency, MarkValue ));
if( NewEventRxd == TRUE )
{
if( EventRxd == STCLKRV_PCR_VALID_EVT )
{
STTBX_Print(( "Last event = PCR Valid \t\r" ));
}
else if( EventRxd == STCLKRV_PCR_DISCONTINUITY_EVT )
{
STTBX_Print(( "Last event = PCR Discontinuity\t\r" ));
}
else if( EventRxd == STCLKRV_PCR_GLITCH_EVT )
{
STTBX_Print(( "Last event = PCR Glitch \t\r" ));
}
}
else
{
STTBX_Print(( " \t\r" ));
}
PrevTime = CurrTime;
CurrTime = time_now();
ElapTime = time_minus( CurrTime, PrevTime );
PCRTicks += ( (PCRFrequency * (ElapTime/200)) / (ST_GetClocksPerSecond()/200) );
STCTicks += ( ( STCFrequency * (ElapTime/200) ) / (ST_GetClocksPerSecond()/200) );
/* Glitch is due to late arrival of PCR */
if( GlitchAct )
{
/*PCRBase = PCRExtd = 0;*/
STCBase = STCExtd = 0;
}
else
{
STCBase = STCTicks / CONV90K_TO_27M;
STCExtd = STCTicks - ( STCBase * CONV90K_TO_27M );
}
PCRBase = PCRTicks / CONV90K_TO_27M;
PCRExtd = PCRTicks - ( PCRBase * CONV90K_TO_27M );
(*ActionPCR)( JumpInPCR, BaseB32, PCRBase, PCRExtd,
BaseB32, STCBase, STCExtd );
JumpInPCR = FALSE;
GlitchAct = FALSE;
RetValue = STTBX_InputPollChar(( &KeyBuff ));
/* STTBX_Print(( "RetValue=%ld, KeyBuff=%ld\n", RetValue, KeyBuff )); */
if( RetValue != 0L )
{
KeyCode = (U8)KeyBuff;
/* STTBX_Print(( "KeyCode=%d\n", ((U32) KeyCode) )); */
switch( KeyCode )
{
case 'q':
case 'Q':
STTBX_Print(( "\nTerminating Interactive Test\n" ));
Running = FALSE;
break;
case 'e': /* JF added */
case 'E':
JumpInPCR = TRUE;
PCRTicks = CurrTime;
break;
case 'j':
case 'J':
PCRTicks = CurrTime;
break;
case 'u':
PCRFrequency += SMALL_PCR_NUDGE;
break;
case 'U':
PCRFrequency += LARGE_PCR_NUDGE;
break;
case 'd':
PCRFrequency -= SMALL_PCR_NUDGE;
break;
case 'D':
PCRFrequency -= LARGE_PCR_NUDGE;
break;
case 'g':
case 'G':
GlitchAct = TRUE;
/* ***NO BREAK*** */
default:
break;
}
}
}
/* Close Clock Recovery explicitly */
STTBX_Print(( "Calling STCLKRV_Close() .............\n" ));
ReturnError = STCLKRV_Close( Handle );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Unforced Clock Recovery Termination */
TermParams_s.ForceTerminate = FALSE;
STTBX_Print(( "Calling STCLKRV_Term() unforced .....\n" ));
ReturnError = STCLKRV_Term( DeviceNam, &TermParams_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Terminate the subordinate PWM Driver */
PWMTermPars_s.ForceTerminate = FALSE;
STTBX_Print(( "Calling STPWM_Term() unforced .......\n" ));
ReturnError = STPWM_Term( PWMDevNam, &PWMTermPars_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Terminate the sub-subordinate PIO Driver */
PIOTermPars_s.ForceTerminate = FALSE;
STTBX_Print(( "Calling STPIO_Term() ................\n" ));
ReturnError = STPIO_Term( PIODevNam, &PIOTermPars_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
/* Terminate the subordinate EVT Driver */
EVTTermPars_s.ForceTerminate = TRUE;
STTBX_Print(( "Calling STEVT_Term() ................\n" ));
ReturnError = STEVT_Term( EVTDevNam, &EVTTermPars_s );
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
STTBX_Print(( "\nOverall test result is " ));
ReturnError = StoredError;
ErrorReport( &StoredError, ReturnError, ST_NO_ERROR );
}
MemberType GetMemberType(ObjectType obj, LubeToken token)
{
if (!IsMemberToken(token)) {
ErrorReport(Lube_E_UnexpectSymbol, g_szCurrentToken);
return Member_None;
}
switch (token) {
case Token_K_name:
return Member_Name;
case Token_K_namespace:
return Member_NameSpace;
case Token_K_fullname:
return Member_FullName;
case Token_K_type:
return Member_Type;
case Token_K_attrib:
return Member_Attrib;
case Token_K_version:
if (Object_Module != obj) {
ErrorReport(Lube_E_InvalidMember, "version");
return Member_None;
}
return Member_Version;
case Token_K_majorversion:
if (Object_Module != obj) {
ErrorReport(Lube_E_InvalidMember, "majorversion");
return Member_None;
}
return Member_Major_Version;
case Token_K_minorversion:
if (Object_Module != obj) {
ErrorReport(Lube_E_InvalidMember, "minorversion");
return Member_None;
}
return Member_Minor_Version;
case Token_K_uuid:
if (Object_Module != obj && Object_Interface != obj
&& Object_Parent != obj && Object_ClsIntf != obj
&& Object_ClsIntfAndParents != obj
&& Object_Class != obj && Object_Super != obj
&& Object_Aspect != obj && Object_Aggregate != obj) {
ErrorReport(Lube_E_InvalidMember, "uuid");
return Member_None;
}
return Member_Uuid;
case Token_K_uunm:
if (Object_Module != obj) {
ErrorReport(Lube_E_InvalidMember, "uunm");
return Member_None;
}
return Member_Uunm;
case Token_K_clsid:
if (Object_Class != obj && Object_Super != obj
&& Object_Aspect != obj && Object_Aggregate != obj) {
ErrorReport(Lube_E_InvalidMember, "clsid");
return Member_None;
}
return Member_Clsid;
case Token_K_carcode:
if (Object_Module != obj) {
ErrorReport(Lube_E_InvalidMember, "carcode");
return Member_None;
}
return Member_CarCode;
case Token_K_builddate:
if (Object_Module != obj) {
ErrorReport(Lube_E_InvalidMember, "builddate");
return Member_None;
}
return Member_BuildDate;
case Token_K_iid:
if (Object_Interface != obj && Object_Parent != obj
&& Object_ClsIntf != obj && Object_ClsIntfAndParents != obj) {
ErrorReport(Lube_E_InvalidMember, "iid");
return Member_None;
}
return Member_Iid;
case Token_K_value:
if (Object_EnumMember != obj && Object_Const != obj && Object_IntfConst != obj) {
ErrorReport(Lube_E_InvalidMember, "value");
return Member_None;
}
return Member_Value;
case Token_K_dimention:
return Member_Dimention;
default:
assert(TRUE == FALSE);
return Member_None;
}
}
