int _CRTAPI1
rc_main(
int argc,
char**argv
)
{
PCHAR r;
PCHAR x;
PCHAR s1, s2, s3;
int n;
PCHAR pchIncludeT;
ULONG cchIncludeMax;
int fInclude = TRUE; /* by default, search INCLUDE */
int fIncludeCurrentFirst = TRUE; /* by default, add current dir to start of includes */
int cDefine = 0;
int cUnDefine = 0;
PCHAR pszDefine[cDefineMax];
PCHAR pszUnDefine[cDefineMax];
CHAR szDrive[_MAX_DRIVE];
CHAR szDir[_MAX_DIR];
CHAR szFName[_MAX_FNAME];
CHAR szExt[_MAX_EXT];
CHAR szFullPath[_MAX_PATH];
CHAR szIncPath[_MAX_PATH];
CHAR buf[10];
CHAR *szRC;
PCHAR *ppargv;
int rcpp_argc;
/* Set up for this run of RC */
if (_setjmp(jb)) {
return Nerrors;
}
hHeap = RCInit();
if (hHeap == NULL) {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1120), 0x01000000);
quit(Msg_Text);
}
pchInclude = pchIncludeT = MyAlloc(_MAX_PATH*2);
cchIncludeMax = _MAX_PATH*2;
szRC = argv[0];
/* process the command line switches */
while ((argc > 1) && (IsSwitchChar(*argv[1]))) {
switch (toupper(argv[1][1])) {
case '?':
case 'H':
/* print out help, and quit */
SendError("\n");
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(10001),
VER_PRODUCTVERSION_STR, VER_PRODUCTBUILD);
SendError(Msg_Text);
SendError(GET_MSG(20001));
SendError("\n");
return 0; /* can just return - nothing to cleanup, yet. */
case 'B':
if (toupper(argv[1][2]) == 'R') { /* base resource id */
unsigned long id;
if (isdigit(argv[1][3]))
argv[1] += 3;
else if (argv[1][3] == ':')
argv[1] += 4;
else {
argc--;
argv++;
if (argc <= 1)
goto BadId;
}
if (*(argv[1]) == 0)
goto BadId;
id = atoi(argv[1]);
if (id < 1 || id > 32767)
quit(GET_MSG(1210));
idBase = (WORD)id;
break;
BadId:
quit(GET_MSG(1209));
}
break;
case 'C':
/* Check for the existence of CodePage Number */
if (argv[1][2])
argv[1] += 2;
else {
argc--;
argv++;
}
/* Now argv point to first digit of CodePage */
if (!argv[1])
quit(GET_MSG(1204));
uiCodePage = atoi(argv[1]);
if (uiCodePage == 0)
quit(GET_MSG(1205));
/* Check if uiCodePage exist in registry. */
if (!IsValidCodePage (uiCodePage))
quit(GET_MSG(1206));
break;
case 'D':
/* if not attached to switch, skip to next */
if (argv[1][2])
argv[1] += 2;
else {
argc--;
argv++;
}
/* remember pointer to string */
pszDefine[cDefine++] = argv[1];
if (cDefine > cDefineMax) {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1105), argv[1]);
quit(Msg_Text);
}
break;
case 'F':
switch (toupper(argv[1][2])) {
case 'O':
if (argv[1][3])
argv[1] += 3;
else {
argc--;
argv++;
}
if (argc > 1)
strcpy(resname, argv[1]);
else
quit(GET_MSG(1101));
break;
default:
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1103), argv[1]);
quit(Msg_Text);
}
break;
case 'I':
/* add string to directories to search */
/* note: format is <path>\0<path>\0\0 */
/* if not attached to switch, skip to next */
if (argv[1][2])
argv[1] += 2;
else {
argc--;
argv++;
}
if (!argv[1])
quit(GET_MSG(1201));
if ((strlen(argv[1]) + 1 + strlen(pchInclude)) >= cchIncludeMax) {
cchIncludeMax = strlen(pchInclude) + strlen(argv[1]) + _MAX_PATH*2;
pchIncludeT = MyAlloc(cchIncludeMax);
strcpy(pchIncludeT, pchInclude);
MyFree(pchInclude);
pchInclude = pchIncludeT;
pchIncludeT = pchInclude + strlen(pchIncludeT) + 1;
}
/* if not first switch, write over terminator with semicolon */
if (pchInclude != pchIncludeT)
pchIncludeT[-1] = ';';
/* copy the path */
while ((*pchIncludeT++ = *argv[1]++) != 0)
;
break;
case 'L':
/* if not attached to switch, skip to next */
if (argv[1][2])
argv[1] += 2;
else {
argc--;
argv++;
}
if (!argv[1])
quit(GET_MSG(1202));
if (sscanf( argv[1], "%x", &language ) != 1)
quit(GET_MSG(1203));
while (*argv[1]++ != 0)
;
break;
case 'M':
fMacRsrcs = TRUE;
goto MaybeMore;
case 'N':
fAppendNull = TRUE;
goto MaybeMore;
case 'P':
fPreprocessOnly = TRUE;
break;
case 'R':
goto MaybeMore;
case 'S':
// find out from BRAD what -S does
fAFXSymbols = TRUE;
break;
case 'U':
/* if not attached to switch, skip to next */
if (argv[1][2])
argv[1] += 2;
else {
argc--;
argv++;
}
/* remember pointer to string */
pszUnDefine[cUnDefine++] = argv[1];
if (cUnDefine > cDefineMax) {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1104), argv[1]);
quit(Msg_Text);
}
break;
case 'V':
fVerbose = TRUE; // AFX doesn't set this
goto MaybeMore;
case 'X':
/* remember not to add INCLUDE path */
fInclude = FALSE;
// VC seems to feel the current dir s/b added first no matter what...
// If -X! is specified, don't do that.
if (argv[1][2] == '!') {
fIncludeCurrentFirst = FALSE;
argv[1]++;
}
MaybeMore: /* check to see if multiple switches, like -xrv */
if (argv[1][2]) {
argv[1][1] = '-';
argv[1]++;
continue;
}
break;
case 'Z':
/* if not attached to switch, skip to next */
if (argv[1][2])
argv[1] += 2;
else {
argc--;
argv++;
}
if (!argv[1])
quit(GET_MSG(1211));
s3 = strchr(argv[1], '/');
if (s3 == NULL)
quit(GET_MSG(1212));
*s3 = '\0';
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, s3+1, -1, szSubstituteFontName, MAXTOKSTR);
s1 = argv[1];
do {
s2 = strchr(s1, ',');
if (s2 != NULL)
*s2 = '\0';
if (strlen(s1)) {
if (nBogusFontNames >= 16)
quit(GET_MSG(1213));
pszBogusFontNames[nBogusFontNames] = MyAlloc((strlen(s1)+1) * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, s1, -1, pszBogusFontNames[nBogusFontNames], MAXTOKSTR);
nBogusFontNames += 1;
}
if (s2 != NULL)
*s2++ = ',';
}
while (s1 = s2);
*s3 = '/';
while (*argv[1]++ != 0)
;
break;
default:
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1106), argv[1]);
quit(Msg_Text);
}
/* get next argument or switch */
argc--;
argv++;
}
/* make sure we have at least one file name to work with */
if (argc != 2 || *argv[1] == '\0')
quit(GET_MSG(1107));
if (fVerbose) {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(10001),
VER_PRODUCTVERSION_STR, VER_PRODUCTBUILD);
printf(Msg_Text);
printf("%s\n", GET_MSG(10002));
}
// Support Multi Code Page
// If user did NOT indicate code in command line, we have to set Default
// for NLS Conversion
if (uiCodePage == 0) {
CHAR *pchCodePageString;
/* At first, search ENVIRONMENT VALUE */
if ((pchCodePageString = getenv("RCCODEPAGE")) != NULL) {
uiCodePage = atoi(pchCodePageString);
if (uiCodePage == 0 || !IsValidCodePage(uiCodePage))
quit(GET_MSG(1207));
}
else
{
/* We use System ANSI Code page (ACP) */
uiCodePage = GetACP();
}
}
uiDefaultCodePage = uiCodePage;
if (fVerbose)
printf("Using codepage %d as default\n", uiDefaultCodePage);
/* If we have no extension, assumer .rc */
/* If .res extension, make sure we have -fo set, or error */
/* Otherwise, just assume file is .rc and output .res (or resname) */
//
// We have to be careful upper casing this, because the codepage
// of the filename might be in something other than current codepage.
//
MultiByteToWideChar(uiCodePage, MB_PRECOMPOSED, argv[1], -1, tokenbuf, MAXSTR+1);
if (CharUpperBuff(tokenbuf, wcslen(tokenbuf)) == 0)
_wcsupr(tokenbuf);
WideCharToMultiByte(uiCodePage, 0, tokenbuf, -1, argv[1], strlen(argv[1]), NULL, NULL);
_splitpath(argv[1], szDrive, szDir, szFName, szExt);
if (!(*szDir || *szDrive)) {
strcpy(szIncPath, ".;");
} else {
strcpy(szIncPath, szDrive);
strcat(szIncPath, szDir);
strcat(szIncPath, ";.;");
}
if ((strlen(szIncPath) + 1 + strlen(pchInclude)) >= cchIncludeMax) {
cchIncludeMax = strlen(pchInclude) + strlen(szIncPath) + _MAX_PATH*2;
pchIncludeT = MyAlloc(cchIncludeMax);
strcpy(pchIncludeT, pchInclude);
MyFree(pchInclude);
pchInclude = pchIncludeT;
pchIncludeT = pchInclude + strlen(pchIncludeT) + 1;
}
pchIncludeT = MyAlloc(cchIncludeMax);
if (fIncludeCurrentFirst) {
strcpy(pchIncludeT, szIncPath);
strcat(pchIncludeT, pchInclude);
} else {
strcpy(pchIncludeT, pchInclude);
strcat(pchIncludeT, ";");
strcat(pchIncludeT, szIncPath);
}
MyFree(pchInclude);
pchInclude = pchIncludeT;
pchIncludeT = pchInclude + strlen(pchIncludeT) + 1;
if (!szExt[0]) {
strcpy(szExt, ".RC");
}
else if (strcmp (szExt, ".RES") == 0) {
quit (GET_MSG(1208));
}
_makepath(inname, szDrive, szDir, szFName, szExt);
if (fPreprocessOnly) {
_makepath(szPreProcessName, NULL, NULL, szFName, ".rcpp");
}
/* Create the name of the .RES file */
if (resname[0] == 0) {
// if building a Mac resource file, we use .rsc to match mrc's output
_makepath(resname, szDrive, szDir, szFName, fMacRsrcs ? ".RSC" : ".RES");
}
/* create the temporary file names */
szTempFileName = MyAlloc(_MAX_PATH);
_fullpath(szFullPath, resname, _MAX_PATH);
_splitpath(szFullPath, szDrive, szDir, NULL, NULL);
_makepath(szTempFileName, szDrive, szDir, "RCXXXXXX", "");
_mktemp (szTempFileName);
szTempFileName2 = MyAlloc(_MAX_PATH);
_makepath(szTempFileName2, szDrive, szDir, "RDXXXXXX", "");
_mktemp (szTempFileName2);
ppargv = szRCPP;
*ppargv++ = "RCPP";
rcpp_argc = 1;
/* Open the .RES file (deleting any old versions which exist). */
if ((fhBin = fopen(resname, "w+b")) == NULL) {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1109), resname);
quit(Msg_Text);
}
else {
if (fMacRsrcs)
MySeek(fhBin, MACDATAOFFSET, 0);
if (fVerbose) {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(10102), resname);
printf(Msg_Text);
}
/* Set up for RCPP. This constructs the command line for it. */
*ppargv = _strdup("-CP");
rcpp_argc++ ; ppargv++;
_itoa(uiCodePage, buf, 10);
*ppargv = buf;
rcpp_argc++ ; ppargv++;
*ppargv = _strdup("-f");
rcpp_argc++ ; ppargv++;
*ppargv = _strdup(szTempFileName);
rcpp_argc++ ; ppargv++;
*ppargv = _strdup("-g");
rcpp_argc++ ; ppargv++;
if (fPreprocessOnly) {
*ppargv = _strdup(szPreProcessName);
} else {
*ppargv = _strdup(szTempFileName2);
}
rcpp_argc++ ; ppargv++;
*ppargv = _strdup("-DRC_INVOKED");
rcpp_argc++ ; ppargv++;
if (fAFXSymbols) {
*ppargv = _strdup("-DAPSTUDIO_INVOKED");
rcpp_argc++ ; ppargv++;
}
if (fMacRsrcs) {
*ppargv = _strdup("-D_MAC");
rcpp_argc++ ; ppargv++;
}
*ppargv = _strdup("-D_WIN32"); /* to be compatible with C9/VC++ */
rcpp_argc++ ; ppargv++;
*ppargv = _strdup("-pc\\:/");
rcpp_argc++ ; ppargv++;
*ppargv = _strdup("-E");
rcpp_argc++ ; ppargv++;
/* Parse the INCLUDE environment variable */
if (fInclude) {
*ppargv = _strdup("-I.");
rcpp_argc++ ; ppargv++;
/* add seperator if any -I switches */
if (pchInclude != pchIncludeT)
pchIncludeT[-1] = ';';
/* read 'em */
x = getenv("INCLUDE");
if (x == (PCHAR)NULL)
*pchIncludeT = '\000';
else {
if (strlen(pchInclude) + strlen(x) + 1 >= cchIncludeMax) {
cchIncludeMax = strlen(pchInclude) + strlen(x) + _MAX_PATH*2;
pchIncludeT = MyAlloc(cchIncludeMax);
strcpy(pchIncludeT, pchInclude);
MyFree(pchInclude);
pchInclude = pchIncludeT;
}
strcat(pchInclude, x);
pchIncludeT = pchInclude + strlen(pchInclude);
}
}
/* now put includes on the RCPP command line */
for (x = pchInclude ; *x ; ) {
r = x;
while (*x && *x != ';')
x = CharNextA(x);
/* mark if semicolon */
if (*x)
*x-- = 0;
if (*r != '\0' && /* empty include path? */
*r != '%' /* check for un-expanded stuff */
// && strchr(r, ' ') == NULL /* check for whitespace */
) {
/* add switch */
*ppargv = _strdup("-I");
rcpp_argc++ ; ppargv++;
*ppargv = _strdup(r);
rcpp_argc++ ; ppargv++;
}
/* was semicolon, need to fix for searchenv() */
if (*x) {
*++x = ';';
x++;
}
}
/* include defines */
for (n = 0; n < cDefine; n++) {
*ppargv = _strdup("-D");
rcpp_argc++ ; ppargv++;
*ppargv = pszDefine[n];
rcpp_argc++ ; ppargv++;
}
/* include undefine */
for (n = 0; n < cUnDefine; n++) {
*ppargv = _strdup("-U");
rcpp_argc++ ; ppargv++;
*ppargv = pszUnDefine[n];
rcpp_argc++ ; ppargv++;
}
if (rcpp_argc > MAX_CMD) {
quit(GET_MSG(1102));
}
if (fVerbose) {
/* echo the preprocessor command */
printf("RC:");
for (n = 0 ; n < rcpp_argc ; n++) {
wsprintfA(Msg_Text, " %s", szRCPP[n]);
printf(Msg_Text);
}
printf("\n");
}
/* Add .rc with rcincludes into szTempFileName */
if (!RC_PreProcess(inname))
quit(Msg_Text);
/* Run the Preprocessor. */
if (RCPP(rcpp_argc, szRCPP, NULL) != 0)
quit(GET_MSG(1116));
}
if (fPreprocessOnly) {
sprintf(szBuf, "Preprocessed File Created in: %s\n", szPreProcessName);
quit(szBuf);
}
if (fVerbose)
printf("\n%s", inname);
if ((fhInput = fopen(szTempFileName2, "rb")) == NULL_FILE)
quit(GET_MSG(2180));
if (!InitSymbolInfo())
quit(GET_MSG(22103));
LexInit (fhInput);
uiCodePage = uiDefaultCodePage;
ReadRF(); /* create .RES from .RC */
if (!TermSymbolInfo(fhBin))
quit(GET_MSG(22204));
if (!fMacRsrcs)
MyAlign(fhBin); // Pad end of file so that we can concatenate files
CleanUpFiles();
HeapDestroy(hHeap);
return Nerrors; // return success, not quitting.
}
long do_constexpr(void)
{
REG long val;
Parencnt = 0;
Currtok = L_NOTOKEN;
val = constexpr();
if( Currtok == L_RPAREN ) {
if( Parencnt-- == 0 ) {
Msg_Temp = GET_MSG(1012);
SET_MSG (Msg_Text, Msg_Temp, "(");
fatal(1012); /* missing left paren */
}
}
else if( Currtok != L_NOTOKEN ) {
Msg_Temp = GET_MSG(4067);
SET_MSG (Msg_Text, Msg_Temp, PPifel_str);
warning(4067);
}
if( Parencnt > 0 ) {
Msg_Temp = GET_MSG(4012);
SET_MSG (Msg_Text, Msg_Temp, ")");
fatal(4012); /* missing right paren */
}
return(val);
}
/************************************************************************
** definstall - Install a new definition. id is in Reuse_1.
** p_text : ptr to the definition
** n : number of bytes in the definition (may contain embedded nulls)
** number : number of formals
************************************************************************/
void definstall(ptext_t p_text, int n, int number)
{
pdefn_t p;
if(n == 0) {
p_text = NULL;
}
if( strcmp (Reuse_1, "defined") == 0) {
Msg_Temp = GET_MSG (4112);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1, "#define");
warning(4112);/* name reserved */
return;
}
if((p = get_defined()) != 0) {
if(PRE_DEFINED(p)) {
Msg_Temp = GET_MSG (4112);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1, "#define");
warning(4112);/* name reserved */
return;
}
else {
if(redefn(p_text, DEFN_TEXT(p), n)) {
Msg_Temp = GET_MSG (4005);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1);
warning(4005);/* redefinition */
}
else {
return;
}
}
}
else {
hln_t ident;
HLN_NAME(ident) = Reuse_1;
HLN_HASH(ident) = Reuse_1_hash;
HLN_LENGTH(ident) = (UCHAR)Reuse_1_length;
p = malloc(sizeof(defn_t));
if (p == NULL) {
Msg_Temp = GET_MSG (1002);
SET_MSG (Msg_Text, Msg_Temp);
error(1002);
return;
}
DEFN_IDENT(p) = HLN_TO_NAME(&ident);
DEFN_NEXT(p) = Defn_level_0[Reuse_1_hash & LEVEL_0];
DEFN_TEXT(p) = (char*)NULL;
DEFN_EXPANDING(p) = 0;
Defn_level_0[Reuse_1_hash & LEVEL_0] = p;
}
if(n != 0) {
DEFN_TEXT(p) = pstrndup(p_text, n);
if(number == FROM_COMMAND) { /* special case from cmd line */
*(DEFN_TEXT(p) + n - 1) = EOS_DEFINITION; /* for handle_eos */
}
}
DEFN_NFORMALS(p) = (char)((number != FROM_COMMAND) ? number : 0);
}
/************************************************************************
** str_const : gather up a string constant
************************************************************************/
void str_const(VOID)
{
REG WCHAR c;
REG PWCHAR p_buf;
int not_warned_yet = TRUE;
p_buf = yylval.yy_string.str_ptr = Macro_buffer;
/*
** Is it possible that reading this string during a rescan will
** overwrite the expansion being rescanned? No, because a macro
** expansion is limited to the top half of Macro_buffer.
** For Macro_depth > 0, this is like copying the string from
** somewhere in the top half of Macro_buffer to the bottom half
** of Macro_buffer.
** Note that the restriction on the size of an expanded macro is
** stricter than the limit on an L_STRING length. An expanded
** macro is limited to around 1019 bytes, but an L_STRING is
** limited to 2043 bytes.
*/
for(;;) {
switch(CHARMAP(c = GETCH())) {
case LX_NL:
UNGETCH();
strcpy (Msg_Text, GET_MSG (2001));
error(2001);
/*
** FALLTHROUGH
*/
case LX_DQUOTE:
*p_buf++ = L'\0';
yylval.yy_string.str_len = (USHORT)(p_buf-yylval.yy_string.str_ptr);
return;
break;
case LX_EOS:
if(handle_eos() != BACKSLASH_EOS) {
continue;
}
if(InInclude) {
break;
}
else {
c = (WCHAR)escape(get_non_eof()); /* process escaped char */
}
break;
}
if(p_buf - Macro_buffer > LIMIT_STRING_LENGTH) {
if( not_warned_yet ) {
strcpy (Msg_Text, GET_MSG (4009));
warning(4009); /* string too big, truncating */
not_warned_yet = FALSE;
}
}
else {
*p_buf++ = c;
}
}
}
/************************************************************************
** char_const : gather up a character constant
** we're called after finding the openning single quote.
************************************************************************/
token_t char_const(void)
{
REG WCHAR c;
value_t value;
token_t tok;
tok = (token_t)(Jflag ? L_CUNSIGNED : L_CINTEGER);
first_switch:
switch(CHARMAP(c = GETCH())) {
case LX_BACKSLASH:
break;
case LX_SQUOTE:
strcpy (Msg_Text, GET_MSG (2137)); //"empty character constant"
error(2137);
value.v_long = 0;
UNGETCH();
break;
case LX_EOS: /* ??? assumes i/o buffering > 1 char */
if(handle_eos() != BACKSLASH_EOS) {
goto first_switch;
}
value.v_long = escape(get_non_eof());
if( tok == L_CUNSIGNED ) { /* don't sign extend */
value.v_long &= 0xff;
}
break;
case LX_NL:
/* newline in character constant */
strcpy (Msg_Text, GET_MSG (2001));
error (2001);
UNGETCH();
/*
** FALLTHROUGH
*/
default:
value.v_long = c;
break;
}
if((c = get_non_eof()) != L'\'') {
strcpy (Msg_Text, GET_MSG (2015));
error (2015); /* too many chars in constant */
do {
if(c == L'\n') {
strcpy (Msg_Text, GET_MSG (2016));
error(2016); /* missing closing ' */
break;
}
} while((c = get_non_eof()) != L'\'');
}
yylval.yy_tree = build_const(tok, &value);
return(tok);
}
bool TTTTab2::ProcessMessage(Long_t msg, Long_t param1, Long_t /*param2*/)
{
switch (GET_MSG(msg)) {
case kC_COMMAND:
switch (GET_SUBMSG(msg)) {
case kCM_BUTTON:
switch (param1) {
case B_START_2_1:
Startfunc_2_1();
break;
case B_STOP_2_1:
Stopfunc_2_1();
break;
case B_START_2_2:
Startfunc_2_2();
break;
case B_STOP_2_2:
Stopfunc_2_2();
break;
}
break;
}
break;
}
return true;
}
void fatal_in_macro(int e)
{
Linenumber = Macro_line;
Msg_Temp = GET_MSG(e);
SET_MSG (Msg_Text, Msg_Temp);
fatal (e);
}
/************************************************************************
** UNDEFINE - remove a symbol from the symbol table
** No noise is made if the programmer attempts to undefine a predefined
** macro, but it is not done.
************************************************************************/
void undefine(void)
{
pdefn_t pdef;
pdefn_t prev;
prev = NULL;
pdef = Defn_level_0[Reuse_1_hash & LEVEL_0];
while(pdef) {
if(memcmp (Reuse_1, DEFN_IDENT(pdef), Reuse_1_length) == 0) {
if(PRE_DEFINED(pdef)) {
Msg_Temp = GET_MSG (4112);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1, "#undef");
warning(4112);
break;
}
if(prev == NULL) /* match at head of list */
Defn_level_0[Reuse_1_hash & LEVEL_0] = DEFN_NEXT(pdef);
else
DEFN_NEXT(prev) = DEFN_NEXT(pdef);
break;
}
prev = pdef;
pdef = DEFN_NEXT(pdef);
}
}
/************************************************************************
** matol : ascii to long, given a radix.
************************************************************************/
long matol(REG PWCHAR p_start,REG int radix)
{
long result, old_result;
unsigned int i;
old_result = result = 0;
while(*p_start) {
result *= radix;
i = ctoi(*p_start);
if( ((int)i >= radix) && (! Prep) ) {
Msg_Temp = GET_MSG (2020);
SET_MSG (Msg_Text, sizeof(Msg_Text), Msg_Temp, *p_start, radix);
error(2020); /* illegal digit % for base % */
}
result += i;
p_start++;
if(radix == 10) {
if(result < old_result) {
p_start--; /* fix the string ptr since we have overflowed */
break;
}
}
else if(*p_start) {
/*
** the loop is not finished.
** we will multiply by the radix again
** check the upper bits. if they're on, then
** that mult will overflow the value
*/
if(radix == 8) {
if(result & 0xe0000000) {
break;
}
}
else if(result & 0xf0000000) {
break;
}
}
old_result = result;
}
if(*p_start) {
strcpy (Msg_Text, GET_MSG (2177));
error(2177); /* constant too big */
result = 0;
}
return(result);
}
void chkbuf(ptext_t p)
{
if( p >= ELIMIT ) {
Msg_Temp = GET_MSG (1065);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1);
fatal (1065);
}
}
/************************************************************************
* GETID - Get an identifier or keyword.
* (we know that we're given at least 1 id char)
* in addition, we'll hash the value using 'c'.
************************************************************************/
void getid(REG UINT c)
{
REG WCHAR *p;
p = Reuse_W;
*p++ = (WCHAR)c;
c &= HASH_MASK;
repeat:
while(LXC_IS_IDENT(*p = GETCH())) { /* while it's an id char . . . */
c += (*p & HASH_MASK); /* hash it */
p++;
}
if(*p != EOS_CHAR) {
if((*p == L'\\') && (checknl())) {
goto repeat;
}
UNGETCH();
if(p >= LIMIT(Reuse_W)) {
strcpy (Msg_Text, GET_MSG (1067));
fatal(1067);
}
if( ((p - Reuse_W) > LIMIT_ID_LENGTH) && ( ! Prep )) {
p = Reuse_W + LIMIT_ID_LENGTH;
*p++ = L'\0';
c = local_c_hash(Reuse_W);
Msg_Temp = GET_MSG (4011);
SET_MSG (Msg_Text, sizeof(Msg_Text), Msg_Temp, Reuse_W);
warning(4011); /* id truncated */
}
else {
*p++ = L'\0';
}
Reuse_W_hash = (hash_t)c;
Reuse_W_length = (UINT)(p - Reuse_W);
return;
}
if(io_eob()) { /* end of file in middle of id */
strcpy (Msg_Text, GET_MSG (1004));
fatal(1004);
}
goto repeat;
}
VOID *MyAlloc(UINT nbytes)
{
PVOID s;
if ((s = HeapAlloc(hHeap, HEAP_NO_SERIALIZE|HEAP_ZERO_MEMORY, nbytes+8)) != NULL) {
return(((PCHAR)s)+8);
}
else {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1120), nbytes);
quit(Msg_Text);
}
}
UINT MyRead(FILE *fh, VOID *p, UINT n)
{
UINT n1;
n1 = fread(p, 1, (size_t)n, fh);
if (ferror (fh)) {
quit(GET_MSG(1121));
}
else {
return(n1);
}
}
/************************************************************************
** gather_chars : collect chars until a matching one is found.
** skip backslashed chars. moves the chars into the buffer,
** returns a ptr past the last char copied.
************************************************************************/
ptext_t gather_chars(REG ptext_t p, UCHAR match_c)
{
UCHAR c;
*p++ = match_c;
for(;;) {
if(p > ELIMIT) {
return(ELIMIT);
}
switch(CHARMAP(c = GETCH())) {
case LX_NL:
Msg_Temp = GET_MSG (2001);
SET_MSG (Msg_Text, Msg_Temp);
error(2001);
UNGETCH();
c = match_c;
/*
** FALLTHROUGH
*/
case LX_DQUOTE:
case LX_SQUOTE:
if(c == match_c) {
*p++ = c;
return(p); /* only way out */
}
break;
case LX_EOS:
if(handle_eos() != BACKSLASH_EOS) {
continue;
}
else {
/* got backslash */
*p++ = '\\';
c = get_non_eof();
if((c == '\\') && (checknl())) {
continue;
}
}
break;
case LX_LEADBYTE:
*p++ = c;
c = get_non_eof();
break;
}
*p++ = c;
}
}
Bool_t PMTMixed::ProcessMessageThread(Long_t msg, Long_t param1, Long_t /*param2*/)
{
switch (GET_MSG(msg)) {
case kC_COMMAND:
switch (GET_SUBMSG(msg)) {
case kCM_BUTTON:
switch (param1) {
case 1:
withMakingThread();
break;
}
break;
}
break;
}
return true;
}
Bool_t PMTMixed::ProcessMessage(Long_t msg, Long_t param1, Long_t param2)
{
switch (GET_MSG(msg)) {
case kC_COMMAND:
switch (GET_SUBMSG(msg)) {
case kCM_BUTTON:
switch (param1) {
case 0:
withOutMakingThread();
break;
}
break;
}
break;
}
return RunProcessMessageThread(msg, param1, param2);
}
BOOL WINAPI Handler(DWORD fdwCtrlType)
{
if (fdwCtrlType == CTRL_C_EVENT) {
SendError("\n");
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(20101));
SendError(Msg_Text);
CleanUpFiles();
HeapDestroy(hHeap);
/* delete output file */
if (resname)
remove(resname);
return(FALSE);
}
return(FALSE);
}
/************************************************************************
** push_macro: pushes macro information onto the macro stack.
** Information such as the current location in the Exp and Act buffers
** will be used by whatever macros this one may call.
************************************************************************/
void push_macro(pdefn_t pdef)
{
/*
** note that increment leaves element 0 of the macro stack unused.
** this element can be reserved for links to dynamically allocated
** macro expansion stacks, if they become desirable
*/
if(++Macro_depth > LIMIT_MACRO_DEPTH) {
Msg_Temp = GET_MSG (1009);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1);
fatal (1009);
}
Tiny_lexer_nesting++;
CURRENT_MACRO = pdef;
CURRENT_ACTUALS = P_actuals;
CURRENT_NACTUALS = (UCHAR)N_actuals;
CURRENT_NACTSEXPANDED = 0;
CURRENT_STRING = Current_char;
CURRENT_TEXT = Exp_ptr = Save_Exp_ptr;
}
/************************************************************************
* ESCAPE - get an escaped character
*
* ARGUMENTS - none
*
* RETURNS - value of escaped character
*
* SIDE EFFECTS - may push back input
*
* DESCRIPTION - An escape ( '\' ) was discovered in the input. Translate
* the next symbol or symbols into an escape sequence.
*
* AUTHOR - Ralph Ryan, Sept. 7, 1982
*
* MODIFICATIONS - none
*
************************************************************************/
int escape(REG int c)
{
REG int value;
int cnt;
escape_again:
if( LXC_IS_ODIGIT((WCHAR)c) ) {/* \ooo is an octal number, must fit into a byte */
cnt = 1;
for(value = ctoi(c), c = get_non_eof();
(cnt < 3) && LXC_IS_ODIGIT((WCHAR)c);
cnt++, c = get_non_eof()
) {
value *= 8;
value += ctoi(c);
}
if( ! Prep ) {
if(value > 255) {
Msg_Temp = GET_MSG (2022);
SET_MSG (Msg_Text, sizeof(Msg_Text), Msg_Temp, value);
error (2022);
}
}
UNGETCH();
return((char)value);
}
switch( c ) {
case L'a':
return(ALERT_CHAR);
break;
case L'b':
return(L'\b');
break;
case L'f':
return(L'\f');
break;
case L'n':
return fMacRsrcs ? (L'\r') : (L'\n');
break;
case L'r':
return fMacRsrcs ? (L'\n') : (L'\r');
break;
case L't':
return(L'\t');
break;
case L'v':
return(L'\v');
break;
case L'x':
cnt = 0;
value = 0;
c = get_non_eof();
while((cnt < 3) && LXC_IS_XDIGIT((WCHAR)c)) {
value *= 16;
value += ctoi(c);
c = get_non_eof();
cnt++;
}
if(cnt == 0) {
strcpy (Msg_Text, GET_MSG (2153));
error (2153);
}
UNGETCH();
return((char)value); /* cast to get sign extend */
default:
if(c != L'\\') {
return(c);
}
else {
if(checknl()) {
c = get_non_eof();
goto escape_again;
}
else {
return(c);
}
}
}
}
//______________________________________________________________________________
Bool_t ArgusWindow::ProcessMessage(Long_t msg, Long_t param1, Long_t /*param2*/)
{
ArgusTab *tab = 0;
// cout << "ArgusWindow::ProcessMessage " << GET_MSG(msg) << " " << GET_SUBMSG(msg) << " " << param1 << endl;
// Process messages coming from widgets associated with the dialog.
switch (GET_MSG(msg)) {
case kC_COMMAND:
switch (GET_SUBMSG(msg)) {
case kCM_MENU:
tab = GetTabObjectAt(fCurrentTabIndex);
tab->BaseMenuClicked(0, param1);
switch (param1) {
case M_FILE_NEW_WINDOW:
if (!OpenNewWindow(fCurrentTabIndex)) {
return kFALSE;
}
break;
case M_FILE_EXIT:
CloseWindow();
break;
case M_FILE_CONTROLLER:
if (fController->IsHidden()) {
fController->ShowContainer();
}
break;
default:
ProcessMessageNetFolder(param1);
break;
}
break;
case kCM_BUTTON:
break;
case kCM_LISTBOX:
break;
case kCM_TAB:
if (param1 != fCurrentTabID) {
ChangeTab(GetTabObjectIndex(param1));
break;
}
}
break;
case kC_DOCK:
switch (GET_SUBMSG(msg)) {
// hide/show run# and event#
case kDOCK_DOCK:
((TGCompositeFrame*)(fRunNumber->GetParent()->GetParent()))->HideFrame((TGFrame*)(fRunNumber->GetParent()));
((TGCompositeFrame*)(fEventNumber->GetParent()->GetParent()))->HideFrame((TGFrame*)(fEventNumber->GetParent()));
break;
case kDOCK_UNDOCK:
((TGCompositeFrame*)(fRunNumber->GetParent()->GetParent()))->ShowFrame((TGFrame*)(fRunNumber->GetParent()));
((TGCompositeFrame*)(fEventNumber->GetParent()->GetParent()))->ShowFrame((TGFrame*)(fEventNumber->GetParent()));
break;
case kDOCK_SHOW:
((TGCompositeFrame*)(fRunNumber->GetParent()->GetParent()))->HideFrame((TGFrame*)(fRunNumber->GetParent()));
((TGCompositeFrame*)(fEventNumber->GetParent()->GetParent()))->HideFrame((TGFrame*)(fEventNumber->GetParent()));
break;
case kDOCK_HIDE:
((TGCompositeFrame*)(fRunNumber->GetParent()->GetParent()))->ShowFrame((TGFrame*)(fRunNumber->GetParent()));
((TGCompositeFrame*)(fEventNumber->GetParent()->GetParent()))->ShowFrame((TGFrame*)(fEventNumber->GetParent()));
break;
}
break;
}
return kTRUE;
}
/************************************************************************
** get_actuals : Paren must already be found. If all the actuals can
** be read, the macro is pushed and expansion begins. Otherwise,
** this function is quickly exited and lets the tiny lexer take
** care of rescanning.
************************************************************************/
void get_actuals(pdefn_t pdef, int n_formals)
{
/*
** The only concern with this is that a rescan could finish while
** this is trying to collect actuals. When a rescan finishes, it
** may reset Act_ptr and Exp_ptr. Unless these are saved before the
** end of rescan is handled, the part of the actual collected so far
** would be lost.
*/
REG ptext_t start;
UCHAR c;
ptext_t actuals_start;
int paste;
int level;
*Exp_ptr++ = PREVCH(); /* must be oparen */
level = 0;
actuals_start = Act_ptr;
while( level >= 0) {
if(Exp_ptr >= ELIMIT) {
fatal_in_macro(10056);
}
more_white:
if( ! can_get_non_white()) {
return;
}
if(CHARMAP(CHECKCH()) == LX_SLASH) {
SKIPCH();
if(skip_comment()) {
goto more_white;
}
else {
start = Exp_ptr;
*Exp_ptr++ = '/';
}
}
else {
start = Exp_ptr;
}
paste = FALSE;
for(;;) {
switch(CHARMAP(c = GETCH())) {
case LX_CPAREN:
if(--level < 0) {
goto leave_loop;
}
break;
case LX_COMMA:
/*
** if the comma is not at level == 0, it is part of
** a parenthesized list and not a delimiter
*/
if(level == 0) {
goto leave_loop;
}
break;
case LX_SLASH:
if( ! skip_comment()) {
break;
}
if(*(Exp_ptr - 1) == ' ') {
continue;
}
c = ' ';
break;
case LX_CR:
case LX_NL:
case LX_WHITE:
UNGETCH(); /* This char is valid white space */
if( ! can_get_non_white()) {
return;
}
continue;
break;
case LX_OPAREN:
++level;
break;
case LX_DQUOTE:
case LX_SQUOTE:
Exp_ptr = gather_chars(Exp_ptr, c);
continue;
break;
case LX_ID:
*Exp_ptr++ = c;
while(LXC_IS_IDENT(c = GETCH())) {
if(Exp_ptr >= ELIMIT) {
fatal_in_macro(10056);
}
*Exp_ptr++ = c;
}
if(CHARMAP(c) != LX_MACFORMAL) {
UNGETCH();
continue;
}
paste = TRUE;
/*
** FALLTHROUGH
*/
case LX_MACFORMAL:
move_to_exp(do_macformal(&paste));
continue;
break;
case LX_STRFORMAL:
move_to_exp_esc('"', do_strformal());
continue;
break;
case LX_CHARFORMAL:
move_to_exp_esc('\'', do_strformal());
continue;
break;
case LX_EOS:
/*
** Will saving this pointers create dead space in the
** buffers? Yes, but only temporarily.
**
** handle_eos() may reset Act_ptr and Exp_ptr to the
** beginning of the buffers if a rescan is finishing
** and Macro_depth is going to be 0. ANSI allows
** actuals to start within a macro defintion and be
** completed (further actuals and closing paren) later
** in the text.
**
** These buffer pointers will eventually be reset to
** the beginnings of their respective buffers when the
** macro for the actuals being collected right now
** finish rescan
**
** This is special handling for folks who use
** unbalanced parens in macro definitions
*/
{
ptext_t Exp_save;
ptext_t Act_save;
int eos_res;
Exp_save = Exp_ptr;
Act_save = Act_ptr;
if((eos_res = handle_eos()) & (ACTUAL_EOS | RESCAN_EOS)) {
return;
}
Act_ptr = Act_save;
Exp_ptr = Exp_save;
if(eos_res == BACKSLASH_EOS) { /* ??? DFP QUESTION */
*Exp_ptr++ = c; /* save the \ */
c = get_non_eof(); /* get char following \ */
break;
}
}
continue;
break;
}
*Exp_ptr++ = c;
}
leave_loop:
/*
** if the last character was whitespace, hose it
*/
if(CHARMAP(*(Exp_ptr - 1)) == LX_WHITE) {
Exp_ptr--;
}
/*
** if Exp_ptr <= start, foo() was read, don't incr N_actuals
*/
if(Exp_ptr > start) {
N_actuals++;
move_to_actual(start, Exp_ptr);
}
*Exp_ptr++ = c;
}
P_actuals = actuals_start;
if(n_formals < N_actuals) {
Msg_Temp = GET_MSG (4002);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1);
warning(4002);
}
else if(n_formals > N_actuals) {
Msg_Temp = GET_MSG (4003);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1);
warning(4003);
}
if(DEFN_TEXT(pdef)) {
push_macro(pdef);
expand_macro();
}
else {
/*
** the macro expands to nothing (no definition)
** This essentially means delete the macro and its actuals
** from the expanded text
*/
Act_ptr = P_actuals; /* reset pointer to get rid of actuals */
Exp_ptr = Save_Exp_ptr; /* delete macro & actuals from exp text */
}
}
/************************************************************************
* NEWINPUT - A new input file is to be opened, saving the old.
*
* ARGUMENTS
* char *newname - the name of the file
*
* RETURNS - none
*
* SIDE EFFECTS
* - causes input stream to be switched
* - Linenumber is reset to 1
* - storage is allocated for the newname
* - Filename is set to the new name
*
* DESCRIPTION
* The file is opened, and if successful, the current input stream is saved
* and the stream is switched to the new file. If the newname is NULL,
* then stdin is taken as the new input.
*
* AUTHOR - Ralph Ryan, Sept. 9, 1982
*
* MODIFICATIONS - none
*
************************************************************************/
int newinput (char *newname, int m_open)
{
filelist_t *pF;
TEXT_TYPE p;
WCHAR *pwch;
if( newname == NULL ) {
Fp = stdin;
}
else if((Fp = fopen(newname, "rb")) == NULL)
{
if(m_open == MUST_OPEN) {
Msg_Temp = GET_MSG (1013);
SET_MSG (Msg_Text, Msg_Temp, newname);
fatal(1013);
}
return(FALSE);
}
/* now push it onto the file stack */
++Findex;
if(Findex >= LIMIT_NESTED_INCLUDES) {
Msg_Temp = GET_MSG (1014);
SET_MSG (Msg_Text, Msg_Temp);
fatal(1014);
}
pF = &Fstack[Findex];
if(Findex == 0) {
p = &InputBuffer[(IO_BLOCK * 0) + PUSHBACK_BYTES];
pwch = &wchInputBuffer[(IO_BLOCK * 0) + PUSHBACK_BYTES];
pF->fl_bufsiz = SIX_K;
}
else {
filelist_t *pPrevF;
pPrevF = pF - 1;
if(Findex == 1) { /* first level include */
p = &InputBuffer[(IO_BLOCK * 1) + PUSHBACK_BYTES];
pwch = &wchInputBuffer[(IO_BLOCK * 1) + PUSHBACK_BYTES];
pF->fl_bufsiz = FOUR_K;
}
else { /* (Findex > 1) */
/* nested includes . . . */
p = &InputBuffer[(IO_BLOCK * 2) + PUSHBACK_BYTES];
pwch = &wchInputBuffer[(IO_BLOCK * 2) + PUSHBACK_BYTES];
pF->fl_bufsiz = TWO_K;
}
if((pPrevF->fl_numread > TWO_K) || (Findex > 2)) {
/*
** the parent file has read something into the upper section
** or this is a nested include at least 3 deep.
** the child will overwrite some parent info. we must take this
** into account for the parent to reread when the time comes.
** we also must stick in the eos char into the parents buffer.
** (this latter is the useless thing in deeply nested
** includes since we overwrite the thing we just put in. we'll
** handle this later when we fpop the child.)
*/
TEXT_TYPE pCurrC;
long seek_posn;
seek_posn = pPrevF->fl_totalread;
if( Macro_depth != 0 ) {
/*
** in a macro, the 'current char' we want is kept as the
** first thing in the macro structure.
*/
pCurrC = (TEXT_TYPE)Macro_expansion[1].exp_string;
}
else {
pCurrC = (TEXT_TYPE)Current_char;
}
if(pCurrC >= p) {
/*
** p is the start of the child section.
** current char is past it. ie, we've already read some
** from the upper section.
** current char - p = # of characters used in upper section.
** numread = 0 implies there are no chars left from the parent.
** since, this is really the 'end' of the parent's buffer,
** we'll have to update the info so that the next read from the
** parent (after the child is finished) will be the terminator
** and we want the io_eob handler to refill the buffer.
** we reset the parent's cur char ptr to the beginning of its
** buffer, and put the terminator there.
*/
seek_posn += (pCurrC - pPrevF->fl_buffer);
pPrevF->fl_totalread += (pCurrC - pPrevF->fl_buffer);
pPrevF->fl_numread = 0;
if( Macro_depth != 0 ) {
Macro_expansion[1].exp_string = pPrevF->fl_buffer;
}
else {
Current_char = pPrevF->fl_buffer;
}
*(pPrevF->fl_buffer) = EOS_CHAR;
*(pPrevF->fl_pwchBuffer) = EOS_CHAR;
}
else {
/*
** the upper section has not been read from yet,
** but it has been read into.
** 'p' is pointing to the start of the child's buffer.
** we add the terminator to the new end of the parent's buffer.
*/
seek_posn += TWO_K;
pPrevF->fl_numread = TWO_K;
*(pPrevF->fl_buffer + TWO_K) = EOS_CHAR;
*(pPrevF->fl_pwchBuffer + TWO_K) = EOS_CHAR;
}
if (pPrevF->fl_fFileType == DFT_FILE_IS_8_BIT) {
fseek(pPrevF->fl_file, seek_posn, SEEK_SET);
} else {
fseek(pPrevF->fl_file, seek_posn * sizeof (WCHAR), SEEK_SET);
}
}
}
pF->fl_currc = Current_char;/* previous file's current char */
pF->fl_lineno = Linenumber; /* previous file's line number */
pF->fl_file = Fp; /* the new file descriptor */
pF->fl_buffer = p;
pF->fl_pwchBuffer = pwch;
pF->fl_numread = 0;
pF->fl_totalread = 0;
//- Added to support 16-bit files.
//- 8-2-91 David Marsyla.
pF->fl_fFileType = DetermineFileType (Fp);
//- The file type is unknown, warn them and then take a stab at an
//- 8-bit file. 8-2-91 David Marsyla.
if (pF->fl_fFileType == DFT_FILE_IS_UNKNOWN) {
Msg_Temp = GET_MSG (4413);
SET_MSG (Msg_Text, Msg_Temp, newname);
warning (4413);
pF->fl_fFileType = DFT_FILE_IS_8_BIT;
}
vfCurrFileType = pF->fl_fFileType;
Current_char = (ptext_t)p;
io_eob(); /* fill the buffer */
/*
* Note that include filenames will live the entire compiland. This
* puts the burden on the user with MANY include files. Any other
* scheme takes space out of static data.
* Notice also, that we save the previous filename in the new file's
* fl_name.
*/
pF->fl_name = pstrdup(Filename);
strncpy(Filebuff,newname,sizeof(Filebuff));
Linenumber = 0; /* do_newline() will increment to the first line */
if(Eflag) {
emit_line();
fwrite("\n", 1, 1, OUTPUTFILE); /* this line is inserted */
}
do_newline(); /* a new file may have preproc cmd as first line */
return(TRUE);
}
BOOL RC_PreProcess(PCHAR szname)
{
PFILE fhout; /* fhout: is temp file with rcincluded stuff */
PFILE fhin;
CHAR nm[_MAX_PATH*2];
PCHAR pch;
PWCHAR pwch;
PWCHAR pfilename;
WCHAR readszbuf[READ_MAX];
WCHAR szT[ MAXSTR ];
UINT iLine = 0;
int fBlanks = TRUE;
INT fFileType;
/* Open the .RC source file. */
MultiByteToWideChar(uiCodePage, MB_PRECOMPOSED, szname, -1, Filename, MED_BUFFER+1);
fhin = fopen(szname, "rb");
if (!fhin) {
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(1110), szname);
return(FALSE);
}
/* Open the temporary output file. */
fhout = fopen(szTempFileName, "w+b");
if (!fhout) {
strcpy(Msg_Text, GET_MSG(2180));
return(FALSE);
}
/* output the current filename for RCPP messages */
for (pch=nm ; *szname ; szname = CharNextA(szname)) {
*pch++ = *szname;
if (IsDBCSLeadByteEx(uiCodePage, *szname))
*pch++ = *(szname + 1);
/* Hack to fix bug #8786: makes '\' to "\\" */
else if (*szname == '\\')
*pch++ = '\\';
}
*pch++ = '\000';
/* Output the current filename for RCPP messages */
wcscpy(szT, L"#line 1\"");
// hack - strlen("#line 1\"") is 8.
MultiByteToWideChar(uiCodePage, MB_PRECOMPOSED, nm, -1, szT+8, MAXSTR+1-8);
wcscat(szT, L"\"\r\n");
MyWrite(fhout, szT, wcslen(szT) * sizeof(WCHAR));
/* Determine if the input file is Unicode */
fFileType = DetermineFileType (fhin);
/* Process each line of the input file. */
while (fgetl(readszbuf, READ_MAX, fFileType == DFT_FILE_IS_16_BIT, fhin)) {
/* keep track of the number of lines read */
Linenumber = iLine++;
if ((iLine & RC_PREPROCESS_UPDATE) == 0)
UpdateStatus(1, iLine);
/* Skip the Byte Order Mark and the leading bytes. */
pwch = readszbuf;
while (*pwch && (iswspace(*pwch) || *pwch == 0xFEFF))
pwch++;
/* if the line is a rcinclude line... */
if (strpre(L"rcinclude", pwch)) {
/* Get the name of the rcincluded file. */
pfilename = skipblanks(pwch + 9, TRUE);
MyWrite(fhout, L"#include \"", 10 * sizeof(WCHAR));
MyWrite(fhout, pfilename, wcslen(pfilename) * sizeof(WCHAR));
MyWrite(fhout, L"\"\r\n", 3 * sizeof(WCHAR));
}
else if (strpre(L"#pragma", pwch)) {
WCHAR cSave;
pfilename = skipblanks(pwch + 7, FALSE);
if (strpre(L"code_page", pfilename)) {
pfilename = skipblanks(pfilename + 9, FALSE);
if (*pfilename == L'(') {
ULONG cp = 0;
pfilename = skipblanks(pfilename + 1, FALSE);
// BUGBUG really should allow hex/octal, but ...
if (iswdigit(*pfilename)) {
while (iswdigit(*pfilename)) {
cp = cp * 10 + (*pfilename++ - L'0');
}
pfilename = skipblanks(pfilename, FALSE);
}
else if (strpre(L"default", pfilename)) {
cp = uiDefaultCodePage;
pfilename = skipblanks(pfilename + 7, FALSE);
}
if (cp == 0) {
wsprintfA(Msg_Text, "%s%ws", GET_MSG(4212), pfilename);
error(4212);
}
else if (*pfilename != L')') {
strcpy (Msg_Text, GET_MSG (4211));
error(4211);
}
else if (cp == CP_WINUNICODE) {
strcpy (Msg_Text, GET_MSG (4213));
warning(4213);
}
else if (!IsValidCodePage(cp)) {
strcpy (Msg_Text, GET_MSG (4214));
warning(4214);
}
else {
uiCodePage = cp;
/* Copy the #pragma line to the temp file. */
MyWrite(fhout, pwch, wcslen(pwch) * sizeof(WCHAR));
MyWrite(fhout, L"\r\n", 2 * sizeof(WCHAR));
}
}
else {
strcpy (Msg_Text, GET_MSG (4210));
error(4210);
}
}
}
else if (!*pwch)
fBlanks = TRUE;
else {
if (fBlanks) {
swprintf(szT, L"#line %d\r\n", iLine);
MyWrite(fhout, szT, wcslen(szT) * sizeof(WCHAR));
fBlanks = FALSE;
}
/* Copy the .RC line to the temp file. */
MyWrite(fhout, pwch, wcslen(pwch) * sizeof(WCHAR));
MyWrite(fhout, L"\r\n", 2 * sizeof(WCHAR));
}
}
lCPPTotalLinenumber = iLine;
Linenumber = 0;
uiCodePage = uiDefaultCodePage;
fclose(fhout);
fclose(fhin);
return(TRUE);
}
/************************************************************************
** get_definition : accumulate the macro definition, stops when it finds
** a newline (it uses it). returns a ptr to the end of the string it builds.
** builds the string in Macro_buffer. (given the start in P_defn_start)
************************************************************************/
int get_definition(void)
{
REG ptext_t p;
UCHAR c;
int stringize = FALSE;
int charize = FALSE;
p = P_defn_start;
c = skip_cwhite();
for(;;) {
chkbuf(p);
switch(CHARMAP(c)) {
case LX_EOS:
if(handle_eos() == BACKSLASH_EOS) {
/* got backslash EOS */
/* \<anything else> goes out as is. The <anything else>
* character must be emitted now, so that
* #define FOO(name) \name
* . . .
* FOO(bar)
*
* does NOT see occurence of name in the definition as an
* occurence of the formal param and emit \bar when it is
* expanded later,but if the definition is \nname it will
* find name as a formal paramater and emit \nbar
*/
*p++ = c; /* put in backslash, break'll add new char */
c = get_non_eof();
}
else {
c = GETCH();
continue;
}
break;
case LX_NL: /* only way out */
UNGETCH();
if(p == P_defn_start) {
return(0);
}
chkbuf(p);
*p++ = EOS_CHAR;
*p++ = EOS_DEFINITION; /* tells handle_eos defn finished */
return(p - P_defn_start);/* p's last incr counts the 0*/
break;
case LX_DQUOTE:
case LX_SQUOTE:
p = gather_chars(p, c);
c = GETCH();
continue;
break;
case LX_POUND:
split_op:
switch(CHARMAP(GETCH())) {
case LX_POUND:
/*
** handle ## processing. cant be the first or the last.
*/
if(p == P_defn_start) {
Msg_Temp = GET_MSG (2160);
SET_MSG (Msg_Text, Msg_Temp);
error(2160); /* ## not allowed as first entry */
continue;
}
if(*(p - 1) == ' ') { /* hose the last blank */
p--;
}
if(CHARMAP(c = skip_cwhite()) == LX_NL) {
UNGETCH();
Msg_Temp = GET_MSG (2161);
SET_MSG (Msg_Text, Msg_Temp);
error(2161);
continue;
}
/* this case does *not* fall through to LX_ID */
continue;
break;
case LX_EACH:
charize = TRUE;
break;
case LX_EOS:
if( handle_eos() != BACKSLASH_EOS ) {
goto split_op;
}
/*
** FALLTHROUGH
*/
default:
UNGETCH();
stringize = TRUE;
break;
}
if(CHARMAP(c = skip_cwhite()) != LX_ID) {
Msg_Temp = GET_MSG (2162);
SET_MSG (Msg_Text, Msg_Temp);
error(2162); /* must have id following */
continue;
}
/*
** FALLTHROUGH
*/
case LX_ID:
{
/* we have the start of an identifier - check it to see if
* its an occurence of a formal parameter name.
* we gather the id ourselves (instead of getid()) since this
* wil save us from having to copy it to our string if it's
* not a formal parameter.
*/
int n;
ptext_t p_macformal;
p_macformal = p;
do {
chkbuf(p);
*p++ = c;
get_more_id:
c = GETCH();
} while(LXC_IS_IDENT(c));
if(CHARMAP(c) == LX_EOS) {
if(handle_eos() != BACKSLASH_EOS) {
goto get_more_id;
}
}
*p = '\0'; /* term. string, but do not advance ptr */
if((n = is_macro_arg(p_macformal)) >= 1) {
/*
** this is an occurance of formal 'n', replace the id with
** the special MAC character.
*/
p = p_macformal;
if(stringize) {
*p++ = LX_FORMALSTR;
}
else {
if(charize) {
*p++ = LX_FORMALCHAR;
}
else {
*p++ = LX_FORMALMARK;
}
}
*p++ = (UCHAR) n;
}
else if(charize || stringize) {
Msg_Temp = GET_MSG (2162);
SET_MSG (Msg_Text, Msg_Temp);
error(2162);
}
stringize = FALSE;
charize = FALSE;
continue; /* we broke out of the loop with a new char */
}
case LX_SLASH:
if( ! skip_comment() ) { /* really is a slash */
break;
}
/*
** FALLTHROUGH
*/
case LX_CR:
case LX_WHITE:
/*
** this is white space, all contiguous whitespace is transformed
** to 1 blank. (hence the skip_cwhite() and the continue).
*/
if(CHARMAP(c = skip_cwhite()) != LX_NL) {
*p++ = ' ';
}
continue; /* restart loop */
case LX_ILL:
Msg_Temp = GET_MSG (2018);
SET_MSG (Msg_Text, Msg_Temp, c);
error(2018);
c = GETCH();
continue;
}
*p++ = c;
c = GETCH();
}
}
/************************************************************************
** get_formals : collect comma separated idents until the first closing paren
** (the openning paren has already been read)
** since we can't be in a macro when we're asked for this, we can be assured
** that we can use a single buffer to collect all the formal names.
************************************************************************/
void get_formals(void)
{
UCHAR c;
ptext_t p_stop;
ptext_t p_id;
p_id = p_stop = FORMAL_TEXT(P_defn_start);
for(;;) {
switch(CHARMAP(c = skip_cwhite())) {
case LX_ID:
if( p_id != p_stop ) {
Msg_Temp = GET_MSG (2010);
SET_MSG (Msg_Text, Msg_Temp, c);
error (2010);
}
*p_stop++ = c;
for(;;) {
while(LXC_IS_IDENT(c = GETCH())) { /* while an id char */
*p_stop++ = c; /* collect it */
} if(c == EOS_CHAR) {
/*
** found end of buffer marker, make sure it is,
** then handle it.
*/
if(io_eob()) { /* end of buffer in here is bad */
Msg_Temp = GET_MSG (1004);
SET_MSG (Msg_Text, Msg_Temp);
fatal (1004);
}
continue;
}
if((c == '\\') && (checknl())) {
continue;
}
UNGETCH();
break;
}
*p_stop++ = '\0';
break;
case LX_COMMA:
case LX_CPAREN:
if( p_stop > p_id ) {
/* make sure an identifier was read */
if((p_stop - p_id) >= TINY_BUFFER) {
p_id[TINY_BUFFER - 1] = '\0';
Msg_Temp = GET_MSG (4111);
SET_MSG (Msg_Text, Msg_Temp, p_id);
warning(4011); /* id truncated */
p_stop = p_id + TINY_BUFFER;
}
if(is_macro_arg(p_id) >= 1) {
Msg_Temp = GET_MSG (2009);
SET_MSG (Msg_Text, Msg_Temp, p_id);
error(2009); /* reuse of formal */
}
else {
FORMAL_SIZE(P_defn_start) = (UCHAR)(p_stop - P_defn_start);
P_defn_start = p_stop;
N_formals++;
}
}
else {
if( (CHARMAP(c) == LX_COMMA) || (N_formals > 0) ) {
Msg_Temp = GET_MSG (2010);
SET_MSG (Msg_Text, Msg_Temp, c);
error(2010);
}
}
if( CHARMAP(c) == LX_CPAREN ) {
return;
}
p_id = p_stop = FORMAL_TEXT(P_defn_start);
break;
default:
Msg_Temp = GET_MSG (2010);
SET_MSG (Msg_Text, Msg_Temp, c);
error(2010); /* unexpected char in formal list */
break;
}
}
}
/************************************************************************
** handle_eos : handle the end of a string.
************************************************************************/
int handle_eos(void)
{
if(PREVCH() == '\\') {
if(checknl()) {
return(FILE_EOS);
}
else {
return(BACKSLASH_EOS);
}
}
if(Macro_depth == 0) { /* found end of file buffer or backslash */
if(io_eob()) { /* end of buffer in here is bad */
Msg_Temp = GET_MSG(1004);
SET_MSG (Msg_Text, Msg_Temp);
fatal (1004);
}
return(FILE_EOS);
}
again:
switch(GETCH()) {
case EOS_PAD:
goto again;
case EOS_ACTUAL:
/*
** Just finished expanding actual. Check to see if there are
** any more actuals to be expanded. If there are, set up to
** expand them and return. Otherwise, set up to expand defn
*/
/* move expanded text of this actual to act_buffer */
move_to_actual(CURRENT_TEXT, Exp_ptr);
/* reset Exp_ptr for more expansions at this macro depth */
Exp_ptr = CURRENT_TEXT;
/* expand next actual if there, otherwise expand definition */
expand_macro();
return(ACTUAL_EOS);
break;
case EOS_DEFINITION:
if(rescan_expansion()) {
return(RESCAN_EOS);
}
else {
return(DEFINITION_EOS);
}
break;
case EOS_RESCAN:
/*
** Reset Current_char, Exp_ptr and Act_ptr, pop the macro
*/
/* get input from the previous stream */
Current_char = CURRENT_STRING;
/* mark this macro as not expanding */
DEFN_EXPANDING(CURRENT_MACRO)--;
/*
** if looking for the actuals of a macro, these pointers
** should really not be reset, however, it is cleaner to
** save them before calling handle_eos, and restore them
** upon returning, than check a static variable here.
*/
if(Macro_depth == 1) {
Act_ptr = ACT_BUFFER;
Exp_ptr = EXP_BUFFER;
}
--Macro_depth;
return(DEFINITION_EOS);
break;
/* the following conditional compile is so brackets match */
}
}
//______________________________________________________________________________
Bool_t KVFileDialog::ProcessMessage(Long_t msg, Long_t parm1, Long_t)
{
// Process messages generated by the user input in the file dialog.
if (!fFc->GetDisplayStat()) return kTRUE; // Cancel button was pressed
TGTreeLBEntry *e;
TGTextLBEntry *te;
TGFileItem *f;
void *p = 0;
TString txt;
TString sdir = gSystem->WorkingDirectory();
switch (GET_MSG(msg)) {
case kC_COMMAND:
switch (GET_SUBMSG(msg)) {
case kCM_BUTTON:
switch (parm1) {
case kIDF_OK:
// same code as under kTE_ENTER
if ((fDlgMode!=kKVFDDirectory) && (fTbfname->GetTextLength() == 0)) {
txt = "Please provide file name or use \"Cancel\"";
new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
"Missing File Name", txt, kMBIconExclamation,
kMBOk);
return kTRUE;
} else if (!gSystem->AccessPathName(fTbfname->GetString(), kFileExists) &&
!strcmp(fOk->GetTitle(), "Save") &&
(!(fCheckB->GetState() == kButtonDown))) {
Int_t ret;
txt = TString::Format("File name %s already exists, OK to overwrite it?",
fTbfname->GetString());
new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
"File Name Exist", txt.Data(), kMBIconExclamation,
kMBYes | kMBNo, &ret);
if (ret == kMBNo)
return kTRUE;
}
if (fFileInfo->fMultipleSelection) {
if (fFileInfo->fFilename)
delete [] fFileInfo->fFilename;
fFileInfo->fFilename = 0;
}
else {
if (fFileInfo->fFilename)
delete [] fFileInfo->fFilename;
if (gSystem->IsAbsoluteFileName(fTbfname->GetString()))
fFileInfo->fFilename = StrDup(fTbfname->GetString());
else
fFileInfo->fFilename = gSystem->ConcatFileName(fFc->GetDirectory(),
fTbfname->GetString());
fFileInfo->fFilename = StrDup(gSystem->UnixPathName(gSystem->ExpandPathName(fFileInfo->fFilename)));
}
if (fCheckB && (fCheckB->GetState() == kButtonDown))
fFileInfo->fOverwrite = kTRUE;
else
fFileInfo->fOverwrite = kFALSE;
DeleteWindow();
break;
case kIDF_CANCEL:
if (fFileInfo->fFilename)
delete [] fFileInfo->fFilename;
fFileInfo->fFilename = 0;
if (fFc->GetDisplayStat())
fFc->SetDisplayStat(kFALSE);
if (fFileInfo->fFileNamesList != 0) {
fFileInfo->fFileNamesList->Delete();
fFileInfo->fFileNamesList = 0;
}
DeleteWindow();
return kTRUE; //no need to redraw fFc
break;
case kIDF_CDUP:
fFc->ChangeDirectory("..");
fTreeLB->Update(fFc->GetDirectory());
if (fFileInfo->fIniDir) delete [] fFileInfo->fIniDir;
fFileInfo->fIniDir = StrDup(fFc->GetDirectory());
if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
gSystem->cd(fFc->GetDirectory());
}
break;
case kIDF_NEW_FOLDER: {
char answer[128];
strlcpy(answer, "(empty)", sizeof(answer));
new TGInputDialog(gClient->GetRoot(), GetMainFrame(),
"Enter directory name:",
answer/*"(empty)"*/, answer);
while ( strcmp(answer, "(empty)") == 0 ) {
new TGMsgBox(gClient->GetRoot(), GetMainFrame(), "Error",
"Please enter a valid directory name.",
kMBIconStop, kMBOk);
new TGInputDialog(gClient->GetRoot(), GetMainFrame(),
"Enter directory name:",
answer, answer);
}
if ( strcmp(answer, "") == 0 ) // Cancel button was pressed
break;
if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
gSystem->cd(fFc->GetDirectory());
}
if ( gSystem->MakeDirectory(answer) != 0 )
new TGMsgBox(gClient->GetRoot(), GetMainFrame(), "Error",
TString::Format("Directory name \'%s\' already exists!", answer),
kMBIconStop, kMBOk);
else {
fFc->DisplayDirectory();
}
gSystem->ChangeDirectory(sdir.Data());
break;
}
case kIDF_LIST:
fFv->SetViewMode(kLVList);
fDetails->SetState(kButtonUp);
break;
case kIDF_DETAILS:
fFv->SetViewMode(kLVDetails);
fList->SetState(kButtonUp);
break;
}
break;
case kCM_COMBOBOX:
switch (parm1) {
case kIDF_FSLB:
e = (TGTreeLBEntry *) fTreeLB->GetSelectedEntry();
if (e) {
fFc->ChangeDirectory(e->GetPath()->GetString());
fTreeLB->Update(fFc->GetDirectory());
if (fFileInfo->fIniDir) delete [] fFileInfo->fIniDir;
fFileInfo->fIniDir = StrDup(fFc->GetDirectory());
if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
gSystem->cd(fFc->GetDirectory());
}
}
break;
case kIDF_FTYPESLB:
te = (TGTextLBEntry *) fTypes->GetSelectedEntry();
if (te) {
//fTbfname->Clear();
//fTbfname->AddText(0, fFileInfo->fFileTypes[te->EntryId()+1]);
fFileInfo->fFileTypeIdx = te->EntryId();
fFc->SetFilter(fFileInfo->fFileTypes[fFileInfo->fFileTypeIdx+1]);
fFc->DisplayDirectory();
fClient->NeedRedraw(fName);
}
break;
}
break;
default:
break;
} // switch(GET_SUBMSG(msg))
break;
case kC_CONTAINER:
switch (GET_SUBMSG(msg)) {
case kCT_ITEMCLICK:
if (parm1 == kButton1) {
if (fFc->NumSelected() > 0) {
if ( fFileInfo->fMultipleSelection == kFALSE ) {
TGLVEntry *e2 = (TGLVEntry *) fFc->GetNextSelected(&p);
if ((e2) && !R_ISDIR(((TGFileItem *)e2)->GetType())) {
fTbfname->Clear();
if (e2->GetItemName())
fTbfname->AddText(0, e2->GetItemName()->GetString());
fClient->NeedRedraw(fName);
}
}
else {
TString tmpString;
TList *tmp = fFc->GetSelectedItems();
TObjString *el;
TIter next(tmp);
if ( fFileInfo->fFileNamesList != 0 ) {
fFileInfo->fFileNamesList->Delete();
}
else {
fFileInfo->fFileNamesList = new TList();
}
while ((el = (TObjString *) next())) {
char *s = gSystem->ConcatFileName(fFc->GetDirectory(),
el->GetString());
tmpString += "\"" + el->GetString() + "\" ";
fFileInfo->fFileNamesList->Add(new TObjString(s));
delete [] s;
}
fTbfname->Clear();
fTbfname->AddText(0, tmpString);
fClient->NeedRedraw(fName);
}
}
}
break;
case kCT_ITEMDBLCLICK:
if (parm1 == kButton1) {
if (fFc->NumSelected() == 1) {
f = (TGFileItem *) fFc->GetNextSelected(&p);
if (f && R_ISDIR(f->GetType())) {
fFc->ChangeDirectory(f->GetItemName()->GetString());
fTreeLB->Update(fFc->GetDirectory());
if (fFileInfo->fIniDir) delete [] fFileInfo->fIniDir;
fFileInfo->fIniDir = StrDup(fFc->GetDirectory());
if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
gSystem->cd(fFc->GetDirectory());
}
} else {
if (!strcmp(fOk->GetTitle(), "Save") &&
(!(fCheckB->GetState() == kButtonDown))) {
Int_t ret;
txt = TString::Format("File name %s already exists, OK to overwrite it?",
fTbfname->GetString());
new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
"File Name Exist", txt.Data(), kMBIconExclamation,
kMBYes | kMBNo, &ret);
if (ret == kMBNo)
return kTRUE;
}
if (fFileInfo->fFilename)
delete [] fFileInfo->fFilename;
if (gSystem->IsAbsoluteFileName(fTbfname->GetString()))
fFileInfo->fFilename = StrDup(fTbfname->GetString());
else
fFileInfo->fFilename = gSystem->ConcatFileName(fFc->GetDirectory(),
fTbfname->GetString());
fFileInfo->fFilename = StrDup(gSystem->UnixPathName(gSystem->ExpandPathName(fFileInfo->fFilename)));
if (fCheckB && (fCheckB->GetState() == kButtonDown))
fFileInfo->fOverwrite = kTRUE;
else
fFileInfo->fOverwrite = kFALSE;
DeleteWindow();
}
}
}
break;
default:
break;
} // switch(GET_SUBMSG(msg))
break;
case kC_TEXTENTRY:
switch (GET_SUBMSG(msg)) {
case kTE_ENTER:
// same code as under kIDF_OK
if ((fDlgMode!=kKVFDDirectory) && (fTbfname->GetTextLength() == 0)) {
const char *txt2 = "Please provide file name or use \"Cancel\"";
new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
"Missing File Name", txt2, kMBIconExclamation,
kMBOk);
return kTRUE;
} else if (!gSystem->AccessPathName(fTbfname->GetString(), kFileExists)) {
FileStat_t buf;
if (!gSystem->GetPathInfo(fTbfname->GetString(), buf) &&
R_ISDIR(buf.fMode)) {
fFc->ChangeDirectory(fTbfname->GetString());
fTreeLB->Update(fFc->GetDirectory());
if (strcmp(gSystem->WorkingDirectory(), fFc->GetDirectory())) {
gSystem->cd(fFc->GetDirectory());
}
fName->SetText("", kFALSE);
return kTRUE;
}
else if (!strcmp(fOk->GetTitle(), "Save") &&
(!(fCheckB->GetState() == kButtonDown))) {
Int_t ret;
txt = TString::Format("File name %s already exists, OK to overwrite it?",
fTbfname->GetString());
new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
"File Name Exist", txt.Data(), kMBIconExclamation,
kMBYes | kMBNo, &ret);
if (ret == kMBNo)
return kTRUE;
}
}
if (fFileInfo->fFilename)
delete [] fFileInfo->fFilename;
fFileInfo->fFilename = gSystem->ConcatFileName(fFc->GetDirectory(),
fTbfname->GetString());
fFileInfo->fFilename = StrDup(gSystem->UnixPathName(gSystem->ExpandPathName(fFileInfo->fFilename)));
if (fCheckB && (fCheckB->GetState() == kButtonDown))
fFileInfo->fOverwrite = kTRUE;
else
fFileInfo->fOverwrite = kFALSE;
DeleteWindow();
break;
default:
break;
}
break;
default:
break;
} // switch(GET_MSG(msg))
fClient->NeedRedraw(fFc);
return kTRUE;
}
/************************************************************************
**tl_getid: This function reads an identifier for the tiny lexer
** into EXP_BUFFER. if macformal is found, the text of that actual
** (expanded or not) is appended to the identifier. It is possible
** that this text will contain characters that are not legal
** identifiers so return value is whether checking to see if the
** "identifier" is defined is worth the bother.
************************************************************************/
int tl_getid(UCHAR c)
{
UCHAR *p;
int paste;
int legal_identifier;
int length = 0;
p = Exp_ptr;
paste = FALSE;
legal_identifier = TRUE;
do_handle_macformal:
if(CHARMAP(c) == LX_MACFORMAL) {
ptext_t p_buf;
if((p_buf = do_macformal(&paste)) != 0) {
while( *p_buf ) {
if( ! LXC_IS_IDENT(*p_buf)) {
legal_identifier = FALSE;
}
if(Exp_ptr >= ELIMIT) {
fatal_in_macro(10056);
}
*Exp_ptr++ = *p_buf++;
}
}
}
else {
*Exp_ptr++ = c;
}
do_handle_eos:
while(LXC_IS_IDENT(c = GETCH())) {
if(Exp_ptr >= ELIMIT) {
fatal_in_macro(10056);
}
*Exp_ptr++ = c;
}
if(CHARMAP(c) == LX_NOEXPAND) {
length = (int)GETCH(); /* just skip length */
goto do_handle_eos;
}
if(CHARMAP(c) == LX_MACFORMAL) {
paste = TRUE;
goto do_handle_macformal;
}
UNGETCH();
if(legal_identifier && (length == (Exp_ptr - p))) {
legal_identifier = FALSE;
}
if(legal_identifier) {
if(((Exp_ptr - p) > LIMIT_ID_LENGTH) && ( ! Prep)) {
Exp_ptr = &p[LIMIT_ID_LENGTH];
*Exp_ptr = '\0'; /* terminates identifier for warning */
Msg_Temp = GET_MSG (4011);
SET_MSG (Msg_Text, Msg_Temp, p);
warning(4011); /* id truncated */
}
else {
*Exp_ptr = '\0'; /* terminates identifier for expandable check */
}
/*
** Whether or not we are doing Prep output, we still have to make
** sure the identifier will fit in Reuse_1
*/
if((Exp_ptr - p) > sizeof(Reuse_1)) {
Exp_ptr = &p[LIMIT_ID_LENGTH];
*Exp_ptr = '\0';
Msg_Temp = GET_MSG (4011);
SET_MSG (Msg_Text, Msg_Temp, p);
warning(4011);
}
/*
** copy into Reuse_1 for warnings about mismatched number of
** formals/actuals, and in case it's not expandable
*/
memcpy(Reuse_1, p, (int)((Exp_ptr - p) + 1));
Reuse_1_hash = local_c_hash(Reuse_1);
/*
** the characters from Exp_ptr to p inclusive do not include the
** the hash character, the length character, and the terminating
** null.
*/
Reuse_1_length = (UCHAR)((Exp_ptr - p) + 1);
}
return(legal_identifier);
}
/************************************************************************
** BEGIN DEFINE A MACRO {
************************************************************************/
void define(void)
{
UCHAR c;
if (! (LX_IS_IDENT(c = skip_cwhite())) ) {
Msg_Temp = GET_MSG (2007);
SET_MSG (Msg_Text, Msg_Temp);
error (2007); /* #define syntax */
skip_cnew();
return;
}
getid(c);
N_formals = 0;
P_defn_start = Macro_buffer;
/*
** the next character must be white space or an open paren
*/
first_switch:
switch(CHARMAP(c = GETCH())) {
case LX_OPAREN: /* we have formal parameters */
get_formals(); /* changes N_formals and fills Macro_buffer */
if(N_formals == 0) {/* empty formal list */
/*
** we must special case this since the expand() reads in the
** actual arguments iff there are formal parameters. thus if we
** #define foo() bar()
** . . .
** foo()
** will expand as
** bar()()
** we put the right paren in to fool the expander into looking
** for actuals.
*/
N_formals = -1;
}
break;
case LX_WHITE:
break;
case LX_CR:
goto first_switch;
case LX_SLASH:
if( ! skip_comment()) {
Msg_Temp = GET_MSG (2008);
SET_MSG (Msg_Text, Msg_Temp, '/');
error (2008);
}
break;
case LX_NL: /* no definition */
UNGETCH();
definstall((ptext_t)0, 0, 0);
return;
break;
case LX_EOS:
if(handle_eos() != BACKSLASH_EOS) {
goto first_switch;
}
/* got BACKSLASH_EOS */
/*
** FALLTHROUGH
*/
default:
Msg_Temp = GET_MSG (2008);
SET_MSG (Msg_Text, Msg_Temp, c);
error (2008); /* unexpected character in macro definition */
}
definstall(P_defn_start, get_definition(), N_formals);
}
Bool_t sis3316_flash::ProcessMessage(Long_t msg, Long_t parm1, Long_t c)
{
int return_code ;
static const char *gDefTypes[] = { "binary files", "*.bin",
"all files", "*",
0, 0 };
switch(GET_MSG(msg))
{
case kC_COMMAND:
switch(GET_SUBMSG(msg))
{
case kCM_BUTTON:
switch(parm1){
case BTN_VME_BROWSE:
fiVME.fFileTypes = gDefTypes;
new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fiVME);
if(fiVME.fFilename){
fVMEImgPath->SetText(fiVME.fFilename);
}else{
fVMEImgPath->SetText("");
}
break;
case BTN_VME_PROG:
if(fiVME.fFilename != ""){
fBar_prog->SetBarColor(0x99ffff); // light blue
ptr = this;
return_code = gl_sis3316_adc1->update_firmware(fiVME.fFilename, 0, progressProgCallback);
if(return_code != 0) {
fBar_prog->SetBarColor(0xff6666); // light red
fButReboot->ChangeBackground(this->red);
reboot_prevent_flag = 1 ;
}
else {
fBar_verify->SetBarColor(0x99ffff); // light blue
return_code = gl_sis3316_adc1->verify_firmware(fiVME.fFilename, 0, progressVerifyCallback);
if(return_code != 0) {
fBar_verify->SetBarColor(0xff6666);
fButReboot->ChangeBackground(this->red);
reboot_prevent_flag = 1 ;
}
else {
fBar_verify->SetBarColor(0x00ff00); // green
fButReboot->ChangeBackground(this->green);
reboot_prevent_flag = 0 ;
}
}
}
else {
fBar_prog->SetBarColor(0xff6666);
fButReboot->ChangeBackground(this->red);
reboot_prevent_flag = 1 ;
}
break;
case BTN_ADC1_BROWSE:
fiADC1.fFileTypes = gDefTypes;
new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fiADC1);
if(fiADC1.fFilename){
fADC1ImgPath->SetText(fiADC1.fFilename);
}else{
fADC1ImgPath->SetText("");
}
break;
case BTN_ADC_PROG:
if(fiADC1.fFilename != ""){
fBar_prog->SetBarColor(0x99ffff); // light blue
ptr = this;
return_code = gl_sis3316_adc1->update_firmware(fiADC1.fFilename, 0x400000, progressProgCallback);
if(return_code != 0) {
fBar_prog->SetBarColor(0xff6666); // light red
fButReboot->ChangeBackground(this->red);
reboot_prevent_flag = 1 ;
}
else {
fBar_verify->SetBarColor(0x99ffff); // light blue
return_code = gl_sis3316_adc1->verify_firmware(fiADC1.fFilename, 0x400000, progressVerifyCallback);
if(return_code != 0) {
fBar_verify->SetBarColor(0xff6666);
fButReboot->ChangeBackground(this->red);
reboot_prevent_flag = 1 ;
}
else {
fBar_verify->SetBarColor(0x00ff00); // green
fButReboot->ChangeBackground(this->green);
reboot_prevent_flag = 0 ;
}
}
}
else {
fBar_prog->SetBarColor(0xff6666);
fButReboot->ChangeBackground(this->red);
reboot_prevent_flag = 1 ;
}
break;
case BTN_REBOOT:
if(reboot_prevent_flag == 0) {
gl_sis3316_adc1->register_write(0x10, 0x80000000); // kill other "Interface Grant"
gl_sis3316_adc1->register_write(0x10, 0x1); // set own "Interface Grant"
gl_sis3316_adc1->register_write(0x0, 0x8000); // reboot FPGAs ; switch SW80-7 has to be on (Watchdog)
}
break;
}
}
//
break;
#ifdef NOT_IMPLEMENTED
case kCM_CHECKBUTTON:
if(fChkADCImgSelect->GetState() == kButtonUp){
fGrpADC->HideFrame(fHorADC2);
fGrpADC->HideFrame(fHorADC3);
fGrpADC->HideFrame(fHorADC4);
fGrpADC->HideFrame(fLblADC2Img);
fGrpADC->HideFrame(fLblADC3Img);
fGrpADC->HideFrame(fLblADC4Img);
}else{
fGrpADC->ShowFrame(fHorADC2);
fGrpADC->ShowFrame(fHorADC3);
fGrpADC->ShowFrame(fHorADC4);
fGrpADC->ShowFrame(fLblADC2Img);
fGrpADC->ShowFrame(fLblADC3Img);
fGrpADC->ShowFrame(fLblADC4Img);
}
break;
#endif
}
return kTRUE;
}
