static void
imfsample_event_proc(ClientData cldata, XEvent *eventPtr)
{
Imfsample *imfsample = (Imfsample *) cldata;
if (eventPtr->type == Expose) {
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, cldata);
imfsample->update_pending = 1;
}
} else if (eventPtr->type == ConfigureNotify) {
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, cldata);
imfsample->update_pending = 1;
}
} else if (eventPtr->type == DestroyNotify) {
if (imfsample->tkwin != NULL) {
imfsample->tkwin = NULL;
Tcl_DeleteCommand(imfsample->interp,
Tcl_GetCommandName(imfsample->interp,
imfsample->widgetCmd));
}
if (imfsample->update_pending) {
Tcl_CancelIdleCall(imfsample_display, cldata);
}
Tcl_EventuallyFree(cldata, imfsample_destroy);
}
}
void
XOTclCallStackDump(Tcl_Interp *interp) {
XOTclCallStack *cs = &RUNTIME_STATE(interp)->cs;
XOTclCallStackContent *csc;
int i=1, entries = cs->top - cs->content;
fprintf (stderr, " XOTCL CALLSTACK: (%d entries, top: %p) \n", entries, cs->top);
for (csc = &cs->content[1]; csc <= cs->top; csc++) {
fprintf(stderr, " %d: %p ",i++,csc);
if (csc->self)
fprintf(stderr, "OBJ %s (%p), ", ObjStr(csc->self->cmdName), csc->self);
if (csc->cl)
fprintf(stderr, "INSTPROC %s->", className(csc->cl));
else
fprintf(stderr, "PROC ");
/*fprintf(stderr, " cmd %p, obj %p, ",csc->cmdPtr, csc->self);*/
if (csc->cmdPtr && !csc->destroyedCmd)
fprintf(stderr, "%s (%p), ", Tcl_GetCommandName(interp, (Tcl_Command)csc->cmdPtr),
csc->cmdPtr);
else
fprintf(stderr, "NULL, ");
fprintf(stderr, "frameType: %d, ", csc->frameType);
fprintf(stderr, "callType: %d ", csc->callType);
fprintf(stderr, "cframe %p ", csc->currentFramePtr);
if (csc->currentFramePtr)
fprintf(stderr,"l=%d ",Tcl_CallFrame_level(csc->currentFramePtr));
if (csc->destroyedCmd)
fprintf(stderr, "--destroyed cmd set (%p) ", csc->destroyedCmd);
fprintf(stderr, "\n");
}
/*
if (entries > 0) {
XOTclCallStackContent *c;
c = XOTclCallStackFindLastInvocation(interp);
fprintf(stderr," --- findLastInvocation %p ",c);
if (c) {
if (c <= cs->top && c->currentFramePtr)
fprintf(stderr," l=%d", Tcl_CallFrame_level(c->currentFramePtr));
}
c = XOTclCallStackFindActiveFrame(interp, 1);
fprintf(stderr," findActiveFrame %p ",c);
if (c) {
if (c <= cs->top && c->currentFramePtr)
fprintf(stderr," l=%d", Tcl_CallFrame_level(c->currentFramePtr));
}
fprintf(stderr," --- \n");
}
*/
}
/*************************************************************************
* FUNCTION : RPMTransaction_Set::Solve *
* ARGUMENTS : transaction set, key, this in disguise *
* RETURNS : -1 (retry), 0 (ignore), 1 (not found) *
* EXCEPTIONS : none *
* PURPOSE : Solve an install problem *
*************************************************************************/
int RPMTransaction_Set::Solve(rpmds key)
{
// Throw the key over to TCL.
Tcl_Obj *cmd[] =
{
Tcl_NewStringObj("::RPM::Solve",-1),
Tcl_NewStringObj(Tcl_GetCommandName(_interp, me),-1),
RPMDependency_Obj::Create_from_ds(key)
};
Tcl_Obj *script = Tcl_NewListObj(sizeof(cmd)/sizeof(cmd[0]),cmd);
Tcl_IncrRefCount(script);
Tcl_EvalObj(_interp,script);
Tcl_DecrRefCount(script);
// Now get the return value
Tcl_Obj *result = Tcl_GetObjResult(_interp);
int rv = 0;
Tcl_GetIntFromObj(_interp,result,&rv);
return rv;
}
static void
PaxWidgetEventProc(ClientData clientData, XEvent *event)
{
PaxWidget *paxwidget = (PaxWidget *) clientData;
if (event->type == Expose || event->type == GraphicsExpose)
{
handle_expose_event(paxwidget, event);
}
else if (event->type == ConfigureNotify)
{
paxWidget_CallMethodArgs(paxwidget->obj, ResizedMethodIdx,
Py_BuildValue("ii", event->xconfigure.width,
event->xconfigure.height));
}
else if (event->type == MapNotify)
{
paxWidget_CallMethod(paxwidget->obj, MapMethodIdx);
}
else if (event->type == DestroyNotify)
{
paxWidget_CallMethod(paxwidget->obj, DestroyMethodIdx);
if (paxwidget->tkwin != NULL)
{
paxwidget->tkwin = NULL;
Tcl_DeleteCommand(paxwidget->interp,
Tcl_GetCommandName(paxwidget->interp,
paxwidget->widget_cmd));
}
if (paxwidget->update_pending)
{
Tk_CancelIdleCall(PaxWidgetDisplay, (ClientData) paxwidget);
}
Tk_EventuallyFree((ClientData) paxwidget, PaxWidgetDestroy);
}
else if (event->type > LASTEvent)
{
paxWidget_CallMethodArgs(paxwidget->obj, ExtensionEventIdx,
Py_BuildValue("(i)", event->type));
}
}
std::string RtclProxyBase::CommandName() const
{
return string(Tcl_GetCommandName(fInterp, fCmdToken));
}
int
TnmSnmpEvalCallback(Tcl_Interp *interp, TnmSnmp *session, TnmSnmpPdu *pdu, char *cmd, char *instance, char *oid, char *value, char *last)
{
char buf[20];
int code;
Tcl_DString tclCmd;
char *startPtr, *scanPtr, *name;
Tcl_DStringInit(&tclCmd);
startPtr = cmd;
for (scanPtr = startPtr; *scanPtr != '\0'; scanPtr++) {
if (*scanPtr != '%') {
continue;
}
Tcl_DStringAppend(&tclCmd, startPtr, scanPtr - startPtr);
scanPtr++;
startPtr = scanPtr + 1;
switch (*scanPtr) {
case 'R':
sprintf(buf, "%d", pdu->requestId);
Tcl_DStringAppend(&tclCmd, buf, -1);
break;
case 'S':
if (session && session->interp && session->token) {
Tcl_DStringAppend(&tclCmd,
Tcl_GetCommandName(session->interp, session->token), -1);
}
break;
case 'V':
Tcl_DStringAppend(&tclCmd, Tcl_DStringValue(&pdu->varbind), -1);
break;
case 'E':
name = TnmGetTableValue(tnmSnmpErrorTable, (unsigned) pdu->errorStatus);
if (name == NULL) {
name = "unknown";
}
Tcl_DStringAppend(&tclCmd, name, -1);
break;
case 'I':
sprintf(buf, "%d", pdu->errorIndex - 1);
Tcl_DStringAppend(&tclCmd, buf, -1);
break;
case 'A':
Tcl_DStringAppend(&tclCmd, inet_ntoa(pdu->addr.sin_addr), -1);
break;
case 'P':
sprintf(buf, "%u", ntohs((unsigned short) pdu->addr.sin_port));
Tcl_DStringAppend(&tclCmd, buf, -1);
break;
#ifdef TNM_SNMPv3
case 'C':
if (pdu->context && pdu->contextLength) {
Tcl_DStringAppend(&tclCmd, pdu->context, pdu->contextLength);
}
break;
case 'G':
if (pdu->engineID && pdu->engineIDLength) {
Tcl_DStringAppend(&tclCmd, pdu->engineID, pdu->engineIDLength);
}
break;
#endif
case 'T':
name = TnmGetTableValue(tnmSnmpPDUTable, (unsigned) pdu->type);
if (name == NULL) {
name = "unknown";
}
Tcl_DStringAppend(&tclCmd, name, -1);
break;
case 'o':
if (instance) {
Tcl_DStringAppend(&tclCmd, instance, -1);
}
break;
case 'i':
if (oid) {
Tcl_DStringAppend(&tclCmd, oid, -1);
}
break;
case 'v':
if (value) {
Tcl_DStringAppend(&tclCmd, value, -1);
}
break;
case 'p':
if (last) {
Tcl_DStringAppend(&tclCmd, last, -1);
}
break;
case '%':
Tcl_DStringAppend(&tclCmd, "%", -1);
break;
default:
sprintf(buf, "%%%c", *scanPtr);
Tcl_DStringAppend(&tclCmd, buf, -1);
}
}
Tcl_DStringAppend(&tclCmd, startPtr, scanPtr - startPtr);
/*
* Now evaluate the callback function and issue a background
* error if the callback fails for some reason. Return the
* original error message and code to the caller.
*/
Tcl_AllowExceptions(interp);
code = Tcl_GlobalEval(interp, Tcl_DStringValue(&tclCmd));
Tcl_DStringFree(&tclCmd);
/*
* Call the usual error handling proc if we have evaluated
* a binding not bound to a specific instance. Bindings
* bound to an instance are usually called during PDU
* processing where it is important to get the error message
* back.
*/
if (code == TCL_ERROR && oid == NULL) {
char *errorMsg = ckstrdup(Tcl_GetStringResult(interp));
Tcl_AddErrorInfo(interp, "\n (snmp callback)");
Tcl_BackgroundError(interp);
Tcl_SetResult(interp, errorMsg, TCL_DYNAMIC);
}
return code;
}
