static void
TclKit_InitStdChannels(void)
{
Tcl_Channel chan;
/*
* We need to verify if we have the standard channels and create them if
* not. Otherwise internals channels may get used as standard channels
* (like for encodings) and panic.
*/
chan = Tcl_GetStdChannel(TCL_STDIN);
if (chan == NULL) {
chan = Tcl_OpenFileChannel(NULL, DEV_NULL, "r", 0);
if (chan != NULL) {
Tcl_SetChannelOption(NULL, chan, "-encoding", "utf-8");
}
Tcl_SetStdChannel(chan, TCL_STDIN);
}
chan = Tcl_GetStdChannel(TCL_STDOUT);
if (chan == NULL) {
chan = Tcl_OpenFileChannel(NULL, DEV_NULL, "w", 0);
if (chan != NULL) {
Tcl_SetChannelOption(NULL, chan, "-encoding", "utf-8");
}
Tcl_SetStdChannel(chan, TCL_STDOUT);
}
chan = Tcl_GetStdChannel(TCL_STDERR);
if (chan == NULL) {
chan = Tcl_OpenFileChannel(NULL, DEV_NULL, "w", 0);
if (chan != NULL) {
Tcl_SetChannelOption(NULL, chan, "-encoding", "utf-8");
}
Tcl_SetStdChannel(chan, TCL_STDERR);
}
}
int tclcommand_replacestdchannel(ClientData clientData, Tcl_Interp *interp, int argc, char **argv)
{
Tcl_Channel channel=NULL;
if (argc != 3){
Tcl_AppendResult(interp,"Wrong # of args! Usage: ",argv[0]," [stdout|stderr|stdin] <pipename>",(char *)NULL);
return TCL_ERROR;
}
if(access(argv[2],F_OK)<0){
Tcl_AppendResult(interp,"File ",argv[2]," does not exist!",(char *) NULL);
return TCL_ERROR;
}
if(strcmp(argv[1],"stdout")==0){
if(access(argv[2],W_OK)<0){
Tcl_AppendResult(interp,"You do not have permission to access ",argv[2],(char *) NULL);
return TCL_ERROR;
}
Tcl_UnregisterChannel(interp,Tcl_GetStdChannel(TCL_STDOUT));
channel = Tcl_OpenFileChannel(interp, argv[2], "WRONLY",0666);
Tcl_RegisterChannel(interp,channel);
Tcl_SetStdChannel(channel,TCL_STDOUT);
}
else if(strcmp(argv[1],"stderr")==0){
if(access(argv[2],W_OK)<0){
Tcl_AppendResult(interp,"You do not have permission to access ",argv[2],(char *) NULL);
return TCL_ERROR;
}
Tcl_UnregisterChannel(interp,Tcl_GetStdChannel(TCL_STDERR));
channel = Tcl_OpenFileChannel(interp, argv[2], "WRONLY",0666);
Tcl_RegisterChannel(interp,channel);
Tcl_SetStdChannel(channel,TCL_STDERR);
}
else if(strcmp(argv[1],"stdin")==0){
if(access(argv[2],R_OK)<0){
Tcl_AppendResult(interp,"You do not have permission to access ",argv[2],(char *) NULL);
return TCL_ERROR;
}
Tcl_UnregisterChannel(interp,Tcl_GetStdChannel(TCL_STDIN));
channel = Tcl_OpenFileChannel(interp, argv[2], "RDONLY",0666);
Tcl_RegisterChannel(interp,channel);
Tcl_SetStdChannel(channel,TCL_STDIN);
}
else{
Tcl_AppendResult(interp,"invalid first argument (got: ",argv[1]," )",(char *) NULL);
return TCL_ERROR;
}
if(channel == NULL)
return TCL_ERROR;
return TCL_OK;
}
static int
SourceRcFile(Tcl_Interp *interp, char *fileName)
{
Tcl_DString temp;
char *fullName;
int result = 0;
if (! fileName) {
return 0;
}
Tcl_DStringInit(&temp);
fullName = Tcl_TranslateFileName(interp, fileName, &temp);
if (fullName == NULL) {
TnmWriteMessage(Tcl_GetStringResult(interp));
TnmWriteMessage("\n");
} else {
Tcl_Channel channel;
channel = Tcl_OpenFileChannel(NULL, fullName, "r", 0);
if (channel) {
Tcl_Close((Tcl_Interp *) NULL, channel);
result = 1;
if (Tcl_EvalFile(interp, fullName) != TCL_OK) {
TnmWriteMessage(Tcl_GetStringResult(interp));
TnmWriteMessage("\n");
}
}
}
Tcl_DStringFree(&temp);
return result;
}
bool ecAdminDialog::EvalTclFile(int nargc, const wxString& Argv, const wxString& msg)
{
wxProgressDialog dlgWait(msg, _("Please wait..."), 100, this);
dlgWait.Update(50);
//TRACE (_T("Evaluating ecosadmin.tcl %s\n"), pszArgv);
// set up the data structure which is passed to the Tcl thread
wxString strArgc;
strArgc.Printf (wxT("%d"), nargc);
std::string argv0 = ecUtils::UnicodeToStdStr (m_strRepository) + "/ecosadmin.tcl";
std::string argv = ecUtils::UnicodeToStdStr (Argv);
std::string argc = ecUtils::UnicodeToStdStr (strArgc);
Tcl_Interp * interp = Tcl_CreateInterp ();
#ifdef __WXMSW__
Tcl_Channel outchan = Tcl_OpenFileChannel (interp, "nul", "a+", 777);
Tcl_SetStdChannel (outchan, TCL_STDOUT); // direct standard output to NUL:
#endif
const char * pszStatus = Tcl_SetVar (interp, "argv0", (char*) argv0.c_str(), 0);
pszStatus = Tcl_SetVar (interp, "argv", (char*) argv.c_str(), 0);
pszStatus = Tcl_SetVar (interp, "argc", (char*) argc.c_str(), 0);
pszStatus = Tcl_SetVar (interp, "gui_mode", "1", 0); // return errors in result string
int nStatus = Tcl_EvalFile (interp, (char*) argv0.c_str());
const char* result = Tcl_GetStringResult (interp);
#ifdef __WXMSW__
Tcl_SetStdChannel (NULL, TCL_STDOUT);
Tcl_UnregisterChannel (interp, outchan);
#endif
Tcl_DeleteInterp (interp);
wxString strErrorMessage (result);
// report any error
if (! strErrorMessage.IsEmpty ())
{
wxString msg (_("Command execution error:\n\n") + strErrorMessage);
wxMessageBox(msg, wxGetApp().GetSettings().GetAppName(), wxICON_EXCLAMATION|wxOK);
return FALSE;
}
else if (TCL_OK != nStatus)
{
wxString msg (_("Command execution error"));
wxMessageBox(msg, wxGetApp().GetSettings().GetAppName(), wxICON_EXCLAMATION|wxOK);
return FALSE;
}
return TRUE;
}
void
Tcl_SourceRCFile(
Tcl_Interp *interp) /* Interpreter to source rc file into. */
{
Tcl_DString temp;
const char *fileName;
Tcl_Channel chan;
fileName = Tcl_GetVar2(interp, "tcl_rcFileName", NULL, TCL_GLOBAL_ONLY);
if (fileName != NULL) {
Tcl_Channel c;
const char *fullName;
Tcl_DStringInit(&temp);
fullName = Tcl_TranslateFileName(interp, fileName, &temp);
if (fullName == NULL) {
/*
* Couldn't translate the file name (e.g. it referred to a bogus
* user or there was no HOME environment variable). Just do
* nothing.
*/
} else {
/*
* Test for the existence of the rc file before trying to read it.
*/
c = Tcl_OpenFileChannel(NULL, fullName, "r", 0);
if (c != NULL) {
Tcl_Obj *fullNameObj = Tcl_NewStringObj(fullName, -1);
Tcl_Close(NULL, c);
Tcl_IncrRefCount(fullNameObj);
if (Tcl_FSEvalFileEx(interp, fullNameObj, NULL) != TCL_OK) {
chan = Tcl_GetStdChannel(TCL_STDERR);
if (chan) {
Tcl_WriteObj(chan, Tcl_GetObjResult(interp));
Tcl_WriteChars(chan, "\n", 1);
}
}
Tcl_DecrRefCount(fullNameObj);
}
}
Tcl_DStringFree(&temp);
}
}
int LoadFromFile(Tcl_Interp * interp, CxImage * image, char * fileName, int Type) {
Tcl_Obj *data = Tcl_NewObj();
Tcl_Channel chan = Tcl_OpenFileChannel(interp, fileName, "r", 0);
BYTE * FileData = NULL;
int length = 0;
int retVal;
if (chan == NULL)
return FALSE;
if (Type == CXIMAGE_FORMAT_UNKNOWN) {
Type = GetFileTypeFromFileName((char *)fileName);
}
if (Type == CXIMAGE_FORMAT_UNKNOWN) {
Type = CXIMAGE_FORMAT_GIF;
}
Tcl_SetChannelOption(interp, chan, "-encoding", "binary");
Tcl_SetChannelOption(interp, chan, "-translation", "binary");
Tcl_ReadChars(chan, data, -1, 0);
Tcl_Close(interp, chan);
FileData = Tcl_GetByteArrayFromObj(data, &length);
if (! image->Decode(FileData, length, Type) &&
! image->Decode(FileData, length, CXIMAGE_FORMAT_GIF) &&
! image->Decode(FileData, length, CXIMAGE_FORMAT_PNG) &&
! image->Decode(FileData, length, CXIMAGE_FORMAT_JPG) &&
! image->Decode(FileData, length, CXIMAGE_FORMAT_TGA) &&
! image->Decode(FileData, length, CXIMAGE_FORMAT_BMP))
retVal = FALSE;
else
retVal = TRUE;
Tcl_DecrRefCount(data);
return retVal;
}
void
Tcl_SourceRCFile(
Tcl_Interp *interp) /* Interpreter to source rc file into. */
{
Tcl_DString temp;
CONST char *fileName;
Tcl_Channel errChannel;
fileName = Tcl_GetVar(interp, "tcl_rcFileName", TCL_GLOBAL_ONLY);
if (fileName != NULL) {
Tcl_Channel c;
CONST char *fullName;
Tcl_DStringInit(&temp);
fullName = Tcl_TranslateFileName(interp, fileName, &temp);
if (fullName == NULL) {
/*
* Couldn't translate the file name (e.g. it referred to a bogus
* user or there was no HOME environment variable). Just do
* nothing.
*/
} else {
/*
* Test for the existence of the rc file before trying to read it.
*/
c = Tcl_OpenFileChannel(NULL, fullName, "r", 0);
if (c != (Tcl_Channel) NULL) {
Tcl_Close(NULL, c);
if (Tcl_EvalFile(interp, fullName) != TCL_OK) {
errChannel = Tcl_GetStdChannel(TCL_STDERR);
if (errChannel) {
Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
Tcl_WriteChars(errChannel, "\n", 1);
}
}
}
}
Tcl_DStringFree(&temp);
}
}
int SaveToFile(Tcl_Interp * interp, CxImage * image, char * fileName, int Type) {
Tcl_Channel chan = Tcl_OpenFileChannel(interp, fileName, "w", 0644);
BYTE * FileData = NULL;
long length = 0;
if (chan == NULL)
return FALSE;
if (Type == CXIMAGE_FORMAT_UNKNOWN) {
Type = GetFileTypeFromFileName((char *)fileName);
}
if (Type == CXIMAGE_FORMAT_UNKNOWN) {
Type = CXIMAGE_FORMAT_GIF;
}
Tcl_SetChannelOption(interp, chan, "-encoding", "binary");
Tcl_SetChannelOption(interp, chan, "-translation", "binary");
if (!image->Encode(FileData, length, Type) ) {
Tcl_AppendResult(interp, image->GetLastError(), NULL);
return TCL_ERROR;
}
Tcl_WriteObj(chan, Tcl_NewByteArrayObj(FileData, length));
image->FreeMemory(FileData);
Tcl_ResetResult(interp);
if (Tcl_Close(interp, chan) == TCL_ERROR)
return FALSE;
else
return TRUE;
}
int
Tcl_AppInit(
Tcl_Interp *interp) /* Interpreter for application. */
{
Tcl_Channel tempChan;
if (Tcl_Init(interp) == TCL_ERROR) {
return TCL_ERROR;
}
#ifdef TCL_TEST
if (Tcltest_Init(interp) == TCL_ERROR) {
return TCL_ERROR;
}
Tcl_StaticPackage(interp, "Tcltest", Tcltest_Init,
(Tcl_PackageInitProc *) NULL);
if (TclObjTest_Init(interp) == TCL_ERROR) {
return TCL_ERROR;
}
#endif /* TCL_TEST */
/*
* Call the init procedures for included packages. Each call should
* look like this:
*
* if (Mod_Init(interp) == TCL_ERROR) {
* return TCL_ERROR;
* }
*
* where "Mod" is the name of the module.
*/
/*
* Call Tcl_CreateCommand for application-specific commands, if
* they weren't already created by the init procedures called above.
* Each call would loo like this:
*
* Tcl_CreateCommand(interp, "tclName", CFuncCmd, NULL, NULL);
*/
/*
* Specify a user-specific startup script to invoke if the application
* is run interactively. On the Mac we can specifiy either a TEXT resource
* which contains the script or the more UNIX like file location
* may also used. (I highly recommend using the resource method.)
*/
Tcl_SetVar(interp, "tcl_rcRsrcName", "tclshrc", TCL_GLOBAL_ONLY);
/* Tcl_SetVar(interp, "tcl_rcFileName", "~/.tclshrc", TCL_GLOBAL_ONLY); */
/*
* We have to support at least the quit Apple Event.
*/
TkMacInitAppleEvents(interp);
/*
* Open a file channel to put stderr, stdin, stdout...
*/
tempChan = Tcl_OpenFileChannel(interp, ":temp.in", "a+", 0);
Tcl_SetStdChannel(tempChan,TCL_STDIN);
Tcl_RegisterChannel(interp, tempChan);
Tcl_SetChannelOption(NULL, tempChan, "-translation", "cr");
Tcl_SetChannelOption(NULL, tempChan, "-buffering", "line");
tempChan = Tcl_OpenFileChannel(interp, ":temp.out", "a+", 0);
Tcl_SetStdChannel(tempChan,TCL_STDOUT);
Tcl_RegisterChannel(interp, tempChan);
Tcl_SetChannelOption(NULL, tempChan, "-translation", "cr");
Tcl_SetChannelOption(NULL, tempChan, "-buffering", "line");
tempChan = Tcl_OpenFileChannel(interp, ":temp.err", "a+", 0);
Tcl_SetStdChannel(tempChan,TCL_STDERR);
Tcl_RegisterChannel(interp, tempChan);
Tcl_SetChannelOption(NULL, tempChan, "-translation", "cr");
Tcl_SetChannelOption(NULL, tempChan, "-buffering", "none");
return TCL_OK;
}
int TclTextInterp::evalString(const char *s) {
#if defined(VMD_NANOHUB)
if (Tcl_Eval(interp, s) != TCL_OK) {
#else
if (Tcl_RecordAndEval(interp, s, 0) != TCL_OK) {
#endif
// Don't print error message if there's nothing to show.
if (strlen(Tcl_GetStringResult(interp)))
msgErr << Tcl_GetStringResult(interp) << sendmsg;
return FALSE;
}
return TRUE;
}
void TclTextInterp::setString(const char *name, const char *val) {
if (interp)
Tcl_SetVar(interp, name, val,
TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG);
}
void TclTextInterp::setMap(const char *name, const char *key,
const char *val) {
if (interp)
Tcl_SetVar2(interp, name, key, val,
TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG);
}
// There's a fair amount of code duplication between doEvent and evalFile,
// maybe these could be combined somehow, say by having TclTextInterp keep
// track of its Tcl_Channel objects.
//
// Side note: Reading line-by-line gives different Tcl semantics than
// just calling Tcl_EvalFile. Shell commands (e.g., stty) are properly
// parsed when read line-by-line and passed to Tcl_RecordAndEval, but are
// unrecognized when contained in a file read by Tcl_EvalFile. I would
// consider this a bug.
int TclTextInterp::evalFile(const char *fname) {
Tcl_Channel inchannel = Tcl_OpenFileChannel(interp, fname, "r", 0644);
Tcl_Channel outchannel = Tcl_GetStdChannel(TCL_STDOUT);
if (inchannel == NULL) {
msgErr << "Error opening file " << fname << sendmsg;
msgErr << Tcl_GetStringResult(interp) << sendmsg;
return 1;
}
Tcl_Obj *cmdPtr = Tcl_NewObj();
Tcl_IncrRefCount(cmdPtr);
int length = 0;
while ((length = Tcl_GetsObj(inchannel, cmdPtr)) >= 0) {
Tcl_AppendToObj(cmdPtr, "\n", 1);
char *stringrep = Tcl_GetStringFromObj(cmdPtr, NULL);
if (!Tcl_CommandComplete(stringrep)) {
continue;
}
// check if "exit" was called
if (app->exitFlag) break;
#if defined(VMD_NANOHUB)
Tcl_EvalObjEx(interp, cmdPtr, 0);
#else
Tcl_RecordAndEvalObj(interp, cmdPtr, 0);
#endif
#if TCL_MINOR_VERSION >= 4
Tcl_DecrRefCount(cmdPtr);
cmdPtr = Tcl_NewObj();
Tcl_IncrRefCount(cmdPtr);
#else
// XXX this crashes Tcl 8.5.[46] with an internal panic
Tcl_SetObjLength(cmdPtr, 0);
#endif
// XXX this makes sure the display is updated
// after each line read from the file or pipe
// So, this is also where we'd optimise reading multiple
// lines at once
//
// In VR modes (CAVE, FreeVR, VR Juggler) the draw method will
// not be called from app->display_update(), so multiple lines
// of input could be combined in one frame, if possible
app->display_update();
Tcl_Obj *resultPtr = Tcl_GetObjResult(interp);
char *bytes = Tcl_GetStringFromObj(resultPtr, &length);
#if defined(VMDTKCON)
if (length > 0) {
vmdcon_append(VMDCON_ALWAYS, bytes,length);
vmdcon_append(VMDCON_ALWAYS, "\n", 1);
}
vmdcon_purge();
#else
if (length > 0) {
#if TCL_MINOR_VERSION >= 4
Tcl_WriteChars(outchannel, bytes, length);
Tcl_WriteChars(outchannel, "\n", 1);
#else
Tcl_Write(outchannel, bytes, length);
Tcl_Write(outchannel, "\n", 1);
#endif
}
Tcl_Flush(outchannel);
#endif
}
Tcl_Close(interp, inchannel);
Tcl_DecrRefCount(cmdPtr);
return 0;
}
static int
FileWritePPM(
Tcl_Interp *interp,
CONST char *fileName,
Tcl_Obj *format,
Tk_PhotoImageBlock *blockPtr)
{
Tcl_Channel chan;
int w, h, greenOffset, blueOffset, nBytes;
unsigned char *pixelPtr, *pixLinePtr;
char header[16 + TCL_INTEGER_SPACE * 2];
chan = Tcl_OpenFileChannel(interp, fileName, "w", 0666);
if (chan == NULL) {
return TCL_ERROR;
}
if (Tcl_SetChannelOption(interp, chan, "-translation", "binary")
!= TCL_OK) {
Tcl_Close(NULL, chan);
return TCL_ERROR;
}
if (Tcl_SetChannelOption(interp, chan, "-encoding", "binary")
!= TCL_OK) {
Tcl_Close(NULL, chan);
return TCL_ERROR;
}
sprintf(header, "P6\n%d %d\n255\n", blockPtr->width, blockPtr->height);
Tcl_Write(chan, header, -1);
pixLinePtr = blockPtr->pixelPtr + blockPtr->offset[0];
greenOffset = blockPtr->offset[1] - blockPtr->offset[0];
blueOffset = blockPtr->offset[2] - blockPtr->offset[0];
if ((greenOffset == 1) && (blueOffset == 2) && (blockPtr->pixelSize == 3)
&& (blockPtr->pitch == (blockPtr->width * 3))) {
nBytes = blockPtr->height * blockPtr->pitch;
if (Tcl_Write(chan, (char *) pixLinePtr, nBytes) != nBytes) {
goto writeerror;
}
} else {
for (h = blockPtr->height; h > 0; h--) {
pixelPtr = pixLinePtr;
for (w = blockPtr->width; w > 0; w--) {
if ( Tcl_Write(chan,(char *)&pixelPtr[0], 1) == -1 ||
Tcl_Write(chan,(char *)&pixelPtr[greenOffset],1)==-1 ||
Tcl_Write(chan,(char *)&pixelPtr[blueOffset],1) ==-1) {
goto writeerror;
}
pixelPtr += blockPtr->pixelSize;
}
pixLinePtr += blockPtr->pitch;
}
}
if (Tcl_Close(NULL, chan) == 0) {
return TCL_OK;
}
chan = NULL;
writeerror:
Tcl_AppendResult(interp, "error writing \"", fileName, "\": ",
Tcl_PosixError(interp), NULL);
if (chan != NULL) {
Tcl_Close(NULL, chan);
}
return TCL_ERROR;
}
char *
TkGetBitmapData(
Tcl_Interp *interp, /* For reporting errors, or NULL. */
const char *string, /* String describing bitmap. May be NULL. */
const char *fileName, /* Name of file containing bitmap description.
* Used only if string is NULL. Must not be
* NULL if string is NULL. */
int *widthPtr, int *heightPtr,
/* Dimensions of bitmap get returned here. */
int *hotXPtr, int *hotYPtr) /* Position of hot spot or -1,-1. */
{
int width, height, numBytes, hotX, hotY;
const char *expandedFileName;
char *p, *end;
ParseInfo pi;
char *data = NULL;
Tcl_DString buffer;
pi.string = string;
if (string == NULL) {
if ((interp != NULL) && Tcl_IsSafe(interp)) {
Tcl_AppendResult(interp, "can't get bitmap data from a file in a",
" safe interpreter", NULL);
return NULL;
}
expandedFileName = Tcl_TranslateFileName(interp, fileName, &buffer);
if (expandedFileName == NULL) {
return NULL;
}
pi.chan = Tcl_OpenFileChannel(interp, expandedFileName, "r", 0);
Tcl_DStringFree(&buffer);
if (pi.chan == NULL) {
if (interp != NULL) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "couldn't read bitmap file \"",
fileName, "\": ", Tcl_PosixError(interp), NULL);
}
return NULL;
}
if (Tcl_SetChannelOption(interp, pi.chan, "-translation", "binary")
!= TCL_OK) {
return NULL;
}
if (Tcl_SetChannelOption(interp, pi.chan, "-encoding", "binary")
!= TCL_OK) {
return NULL;
}
} else {
pi.chan = NULL;
}
/*
* Parse the lines that define the dimensions of the bitmap, plus the
* first line that defines the bitmap data (it declares the name of a data
* variable but doesn't include any actual data). These lines look
* something like the following:
*
* #define foo_width 16
* #define foo_height 16
* #define foo_x_hot 3
* #define foo_y_hot 3
* static char foo_bits[] = {
*
* The x_hot and y_hot lines may or may not be present. It's important to
* check for "char" in the last line, in order to reject old X10-style
* bitmaps that used shorts.
*/
width = 0;
height = 0;
hotX = -1;
hotY = -1;
while (1) {
if (NextBitmapWord(&pi) != TCL_OK) {
goto error;
}
if ((pi.wordLength >= 6) && (pi.word[pi.wordLength-6] == '_')
&& (strcmp(pi.word+pi.wordLength-6, "_width") == 0)) {
if (NextBitmapWord(&pi) != TCL_OK) {
goto error;
}
width = strtol(pi.word, &end, 0);
if ((end == pi.word) || (*end != 0)) {
goto error;
}
} else if ((pi.wordLength >= 7) && (pi.word[pi.wordLength-7] == '_')
&& (strcmp(pi.word+pi.wordLength-7, "_height") == 0)) {
if (NextBitmapWord(&pi) != TCL_OK) {
goto error;
}
height = strtol(pi.word, &end, 0);
if ((end == pi.word) || (*end != 0)) {
goto error;
}
} else if ((pi.wordLength >= 6) && (pi.word[pi.wordLength-6] == '_')
&& (strcmp(pi.word+pi.wordLength-6, "_x_hot") == 0)) {
if (NextBitmapWord(&pi) != TCL_OK) {
goto error;
}
hotX = strtol(pi.word, &end, 0);
if ((end == pi.word) || (*end != 0)) {
goto error;
}
} else if ((pi.wordLength >= 6) && (pi.word[pi.wordLength-6] == '_')
&& (strcmp(pi.word+pi.wordLength-6, "_y_hot") == 0)) {
if (NextBitmapWord(&pi) != TCL_OK) {
goto error;
}
hotY = strtol(pi.word, &end, 0);
if ((end == pi.word) || (*end != 0)) {
goto error;
}
} else if ((pi.word[0] == 'c') && (strcmp(pi.word, "char") == 0)) {
while (1) {
if (NextBitmapWord(&pi) != TCL_OK) {
goto error;
}
if ((pi.word[0] == '{') && (pi.word[1] == 0)) {
goto getData;
}
}
} else if ((pi.word[0] == '{') && (pi.word[1] == 0)) {
if (interp != NULL) {
Tcl_AppendResult(interp, "format error in bitmap data; ",
"looks like it's an obsolete X10 bitmap file", NULL);
}
goto errorCleanup;
}
}
/*
* Now we've read everything but the data. Allocate an array and read in
* the data.
*/
getData:
if ((width <= 0) || (height <= 0)) {
goto error;
}
numBytes = ((width+7)/8) * height;
data = ckalloc((unsigned) numBytes);
for (p = data; numBytes > 0; p++, numBytes--) {
if (NextBitmapWord(&pi) != TCL_OK) {
goto error;
}
*p = (char) strtol(pi.word, &end, 0);
if (end == pi.word) {
goto error;
}
}
/*
* All done. Clean up and return.
*/
if (pi.chan != NULL) {
Tcl_Close(NULL, pi.chan);
}
*widthPtr = width;
*heightPtr = height;
*hotXPtr = hotX;
*hotYPtr = hotY;
return data;
error:
if (interp != NULL) {
Tcl_SetResult(interp, "format error in bitmap data", TCL_STATIC);
}
errorCleanup:
if (data != NULL) {
ckfree(data);
}
if (pi.chan != NULL) {
Tcl_Close(NULL, pi.chan);
}
return NULL;
}
static int
ReadOptionFile(
Tcl_Interp *interp, /* Interpreter to use for reporting results. */
Tk_Window tkwin, /* Token for window: options are entered for
* this window's main window. */
const char *fileName, /* Name of file containing options. */
int priority) /* Priority level to use for options in this
* file, such as TK_USER_DEFAULT_PRIO or
* TK_INTERACTIVE_PRIO. Must be between 0 and
* TK_MAX_PRIO. */
{
const char *realName;
char *buffer;
int result, bufferSize;
Tcl_Channel chan;
Tcl_DString newName;
/*
* Prevent file system access in a safe interpreter.
*/
if (Tcl_IsSafe(interp)) {
Tcl_AppendResult(interp, "can't read options from a file in a",
" safe interpreter", NULL);
return TCL_ERROR;
}
realName = Tcl_TranslateFileName(interp, fileName, &newName);
if (realName == NULL) {
return TCL_ERROR;
}
chan = Tcl_OpenFileChannel(interp, realName, "r", 0);
Tcl_DStringFree(&newName);
if (chan == NULL) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "couldn't open \"", fileName,
"\": ", Tcl_PosixError(interp), NULL);
return TCL_ERROR;
}
/*
* Compute size of file by seeking to the end of the file. This will
* overallocate if we are performing CRLF translation.
*/
bufferSize = (int) Tcl_Seek(chan, (Tcl_WideInt) 0, SEEK_END);
Tcl_Seek(chan, (Tcl_WideInt) 0, SEEK_SET);
if (bufferSize < 0) {
Tcl_AppendResult(interp, "error seeking to end of file \"",
fileName, "\":", Tcl_PosixError(interp), NULL);
Tcl_Close(NULL, chan);
return TCL_ERROR;
}
buffer = ckalloc((unsigned) bufferSize+1);
bufferSize = Tcl_Read(chan, buffer, bufferSize);
if (bufferSize < 0) {
Tcl_AppendResult(interp, "error reading file \"", fileName, "\":",
Tcl_PosixError(interp), NULL);
Tcl_Close(NULL, chan);
return TCL_ERROR;
}
Tcl_Close(NULL, chan);
buffer[bufferSize] = 0;
result = AddFromString(interp, tkwin, buffer, priority);
ckfree(buffer);
return result;
}