/*
** The "p" argument points to a <select>. This routine scans all
** subsequent elements (up to the next </select>) looking for
** <option> tags. For each option tag, it appends three elements
** to the "str" DString:
**
** * 1 or 0 to indicated whether or not the element is
** selected.
**
** * The value returned if this element is selected.
**
** * The text displayed for this element.
*/
static void AddSelectOptions(
Tcl_DString *str, /* Add text here */
HtmlElement *p, /* The <SELECT> markup */
HtmlElement *pEnd /* The </SELECT> markup */
){
while( p && p!=pEnd && p->base.type!=Html_EndSELECT ){
if( p->base.type==Html_OPTION ){
char *zValue;
Tcl_DStringStartSublist(str);
if( HtmlMarkupArg(p, "selected", 0)==0 ){
Tcl_DStringAppend(str, "0 ", 2);
}else{
Tcl_DStringAppend(str, "1 ", 2);
}
zValue = HtmlMarkupArg(p, "value", "");
Tcl_DStringAppendElement(str, zValue);
Tcl_DStringStartSublist(str);
p = p->pNext;
while( p && p!=pEnd && p->base.type!=Html_EndOPTION
&& p->base.type!=Html_OPTION && p->base.type!=Html_EndSELECT ){
if( p->base.type==Html_Text ){
Tcl_DStringAppend(str, p->text.zText, -1);
}else if( p->base.type==Html_Space ){
Tcl_DStringAppend(str, " ", 1);
}
p = p->pNext;
}
Tcl_DStringEndSublist(str);
Tcl_DStringEndSublist(str);
}else{
p = p->pNext;
}
}
}
/* Provide mechanism for simulator to report which instructions are in
which stages */
void report_pc(unsigned fpc, unsigned char fpcv,
unsigned dpc, unsigned char dpcv,
unsigned epc, unsigned char epcv,
unsigned mpc, unsigned char mpcv,
unsigned wpc, unsigned char wpcv)
{
int status;
char addr[10];
char code[12];
Tcl_DString cmd;
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, "simLabel ", -1);
Tcl_DStringStartSublist(&cmd);
if (fpcv) {
sprintf(addr, "%u", fpc);
Tcl_DStringAppendElement(&cmd, addr);
}
if (dpcv) {
sprintf(addr, "%u", dpc);
Tcl_DStringAppendElement(&cmd, addr);
}
if (epcv) {
sprintf(addr, "%u", epc);
Tcl_DStringAppendElement(&cmd, addr);
}
if (mpcv) {
sprintf(addr, "%u", mpc);
Tcl_DStringAppendElement(&cmd, addr);
}
if (wpcv) {
sprintf(addr, "%u", wpc);
Tcl_DStringAppendElement(&cmd, addr);
}
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
sprintf(code, "%s %s %s %s %s",
fpcv ? "F" : "",
dpcv ? "D" : "",
epcv ? "E" : "",
mpcv ? "M" : "",
wpcv ? "W" : "");
Tcl_DStringAppend(&cmd, code, -1);
Tcl_DStringEndSublist(&cmd);
/* Debug
fprintf(stderr, "Code '%s'\n", Tcl_DStringValue(&cmd));
*/
status = Tcl_Eval(sim_interp, Tcl_DStringValue(&cmd));
if (status != TCL_OK) {
fprintf(stderr, "Failed to report pipe code '%s'\n", code);
fprintf(stderr, "Error Message was '%s'\n", sim_interp->result);
}
}
int
Pg_conndefaults(ClientData cData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
{
PQconninfoOption *options = PQconndefaults();
PQconninfoOption *option;
Tcl_DString result;
char ibuf[32];
if (options)
{
Tcl_DStringInit(&result);
for (option = options; option->keyword != NULL; option++)
{
char *val = option->val ? option->val : "";
sprintf(ibuf, "%d", option->dispsize);
Tcl_DStringStartSublist(&result);
Tcl_DStringAppendElement(&result, option->keyword);
Tcl_DStringAppendElement(&result, option->label);
Tcl_DStringAppendElement(&result, option->dispchar);
Tcl_DStringAppendElement(&result, ibuf);
Tcl_DStringAppendElement(&result, val);
Tcl_DStringEndSublist(&result);
}
Tcl_DStringResult(interp, &result);
PQconninfoFree(options);
}
return TCL_OK;
}
static void
DumpPercents(
QE_ExpandArgs *args, /* %-substitution args. */
QE_ExpandProc proc, /* Function to return value for a given
* %-char. */
CONST char *chars /* NULL-terminated list of %-chars. */
)
{
char which = args->which;
char buf[2];
int i;
buf[1] = '\0';
Tcl_DStringStartSublist(args->result);
for (i = 0; chars[i]; i++) {
args->which = chars[i];
buf[0] = chars[i];
Tcl_DStringAppendElement(args->result, buf);
Tcl_DStringAppend(args->result, " ", 1);
(*proc)(args);
}
Tcl_DStringEndSublist(args->result);
args->which = which;
}
void
Tcl_GetMemoryInfo(
Tcl_DString *dsPtr)
{
Cache *cachePtr;
char buf[200];
unsigned int n;
Tcl_MutexLock(listLockPtr);
cachePtr = firstCachePtr;
while (cachePtr != NULL) {
Tcl_DStringStartSublist(dsPtr);
if (cachePtr == sharedPtr) {
Tcl_DStringAppendElement(dsPtr, "shared");
} else {
sprintf(buf, "thread%p", cachePtr->owner);
Tcl_DStringAppendElement(dsPtr, buf);
}
for (n = 0; n < NBUCKETS; ++n) {
sprintf(buf, "%lu %ld %ld %ld %ld %ld %ld",
(unsigned long) bucketInfo[n].blockSize,
cachePtr->buckets[n].numFree,
cachePtr->buckets[n].numRemoves,
cachePtr->buckets[n].numInserts,
cachePtr->buckets[n].totalAssigned,
cachePtr->buckets[n].numLocks,
cachePtr->buckets[n].numWaits);
Tcl_DStringAppendElement(dsPtr, buf);
}
Tcl_DStringEndSublist(dsPtr);
cachePtr = cachePtr->nextPtr;
}
Tcl_MutexUnlock(listLockPtr);
}
void
Ns_ThreadList(Tcl_DString *dsPtr, Ns_ThreadArgProc *proc)
{
Thread *thrPtr;
char buf[100];
Ns_MutexLock(&threadlock);
thrPtr = firstThreadPtr;
while (thrPtr != NULL) {
Tcl_DStringStartSublist(dsPtr);
Tcl_DStringAppendElement(dsPtr, thrPtr->name);
Tcl_DStringAppendElement(dsPtr, thrPtr->parent);
sprintf(buf, " %d %d %ld", thrPtr->tid,
(thrPtr->flags & FLAG_DETACHED) ? NS_THREAD_DETACHED : 0,
thrPtr->ctime.sec);
Tcl_DStringAppend(dsPtr, buf, -1);
if (proc != NULL) {
(*proc)(dsPtr, (void *) thrPtr->proc, thrPtr->arg);
} else {
sprintf(buf, " %p %p", thrPtr->proc, thrPtr->arg);
Tcl_DStringAppend(dsPtr, buf, -1);
}
Tcl_DStringEndSublist(dsPtr);
thrPtr = thrPtr->nextPtr;
}
Ns_MutexUnlock(&threadlock);
}
/*
** Return all tokens between the two elements as a Tcl list.
*/
void HtmlTclizeList(Tcl_Interp *interp, HtmlElement *p, HtmlElement *pEnd){
Tcl_DString str;
int i;
char *zName;
char zLine[100];
Tcl_DStringInit(&str);
while( p && p!=pEnd ){
switch( p->base.type ){
case Html_Block:
break;
case Html_Text:
Tcl_DStringStartSublist(&str);
Tcl_DStringAppendElement(&str,"Text");
Tcl_DStringAppendElement(&str, p->text.zText);
Tcl_DStringEndSublist(&str);
break;
case Html_Space:
sprintf(zLine,"Space %d %d",
p->base.count, (p->base.flags & HTML_NewLine)!=0);
Tcl_DStringAppendElement(&str,zLine);
break;
case Html_Unknown:
Tcl_DStringAppendElement(&str,"Unknown");
break;
default:
Tcl_DStringStartSublist(&str);
Tcl_DStringAppendElement(&str,"Markup");
if( p->base.type >= HtmlMarkupMap[0].type
&& p->base.type <= HtmlMarkupMap[HTML_MARKUP_COUNT-1].type ){
zName = HtmlMarkupMap[p->base.type - HtmlMarkupMap[0].type].zName;
}else{
zName = "Unknown";
}
Tcl_DStringAppendElement(&str, zName);
for(i=0; i<p->base.count; i++){
Tcl_DStringAppendElement(&str, p->markup.argv[i]);
}
Tcl_DStringEndSublist(&str);
break;
}
p = p->pNext;
}
Tcl_DStringResult(interp, &str);
}
// for BIT STRING and INTEGER:
int AsnNamesTypeDesc::TclGetDesc2 (Tcl_DString *desc) const
{
Tcl_DStringStartSublist (desc);
const AsnNameDesc *n;
if (n = names)
for (; n->name; n++)
{
Tcl_DStringStartSublist (desc);
Tcl_DStringAppendElement (desc, (char*) n->name);
char buf[32];
sprintf (buf, "%d", n->value);
Tcl_DStringAppendElement (desc, buf);
Tcl_DStringEndSublist (desc);
}
Tcl_DStringEndSublist (desc);
return TCL_OK;
}
int
TkpTestembedCmd(
ClientData clientData, /* Main window for application. */
Tcl_Interp *interp, /* Current interpreter. */
int argc, /* Number of arguments. */
const char **argv) /* Argument strings. */
{
int all;
Container *containerPtr;
Tcl_DString dString;
char buffer[50];
ThreadSpecificData *tsdPtr =
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
if ((argc > 1) && (strcmp(argv[1], "all") == 0)) {
all = 1;
} else {
all = 0;
}
Tcl_DStringInit(&dString);
for (containerPtr = tsdPtr->firstContainerPtr; containerPtr != NULL;
containerPtr = containerPtr->nextPtr) {
Tcl_DStringStartSublist(&dString);
if (containerPtr->parent == None) {
Tcl_DStringAppendElement(&dString, "");
} else if (all) {
sprintf(buffer, "0x%x", (int) containerPtr->parent);
Tcl_DStringAppendElement(&dString, buffer);
} else {
Tcl_DStringAppendElement(&dString, "XXX");
}
if (containerPtr->parentPtr == NULL) {
Tcl_DStringAppendElement(&dString, "");
} else {
Tcl_DStringAppendElement(&dString,
containerPtr->parentPtr->pathName);
}
if (containerPtr->wrapper == None) {
Tcl_DStringAppendElement(&dString, "");
} else if (all) {
sprintf(buffer, "0x%x", (int) containerPtr->wrapper);
Tcl_DStringAppendElement(&dString, buffer);
} else {
Tcl_DStringAppendElement(&dString, "XXX");
}
if (containerPtr->embeddedPtr == NULL) {
Tcl_DStringAppendElement(&dString, "");
} else {
Tcl_DStringAppendElement(&dString,
containerPtr->embeddedPtr->pathName);
}
Tcl_DStringEndSublist(&dString);
}
Tcl_DStringResult(interp, &dString);
return TCL_OK;
}
int AsnSe_TypeDesc::TclGetDesc2 (Tcl_DString *desc) const
{
Tcl_DStringStartSublist (desc);
const AsnSe_MemberDesc *m;
if (m = members)
for (; m->TclGetDesc (desc) == TCL_OK; m++)
;
Tcl_DStringEndSublist (desc);
return TCL_OK;
}
int AsnEnumTypeDesc::TclGetDesc2 (Tcl_DString *desc) const
{
Tcl_DStringStartSublist (desc);
const AsnNameDesc *n;
if (n = names)
for (; n->name; n++)
Tcl_DStringAppendElement (desc, (char*) n->name);
Tcl_DStringEndSublist (desc);
return TCL_OK;
}
int AsnTypeDesc::TclGetDesc (Tcl_DString *desc) const
{
Tcl_DStringStartSublist (desc);
Tcl_DStringAppendElement (desc, getmodule() ? (char*) getmodule()->name : "");
Tcl_DStringAppendElement (desc, getname() ? (char*) getname() : "");
Tcl_DStringEndSublist (desc);
Tcl_DStringAppendElement (desc, ispdu() ? "pdu" : "sub");
Tcl_DStringAppendElement (desc, (char*) typenames[gettype()]);
return TCL_OK;
}
int
TkpTestembedCmd(
ClientData clientData, /* Main window for application. */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument strings. */
{
int all;
Container *containerPtr;
Tcl_DString dString;
char buffer[50];
if ((objc > 1) && (strcmp(Tcl_GetString(objv[1]), "all") == 0)) {
all = 1;
} else {
all = 0;
}
Tcl_DStringInit(&dString);
for (containerPtr = firstContainerPtr; containerPtr != NULL;
containerPtr = containerPtr->nextPtr) {
Tcl_DStringStartSublist(&dString);
if (containerPtr->parent == None) {
Tcl_DStringAppendElement(&dString, "");
} else if (all) {
sprintf(buffer, "0x%x", (int) containerPtr->parent);
Tcl_DStringAppendElement(&dString, buffer);
} else {
Tcl_DStringAppendElement(&dString, "XXX");
}
if (containerPtr->parentPtr == NULL) {
Tcl_DStringAppendElement(&dString, "");
} else {
Tcl_DStringAppendElement(&dString,
containerPtr->parentPtr->pathName);
}
if (containerPtr->embedded == None) {
Tcl_DStringAppendElement(&dString, "");
} else if (all) {
sprintf(buffer, "0x%x", (int) containerPtr->embedded);
Tcl_DStringAppendElement(&dString, buffer);
} else {
Tcl_DStringAppendElement(&dString, "XXX");
}
if (containerPtr->embeddedPtr == NULL) {
Tcl_DStringAppendElement(&dString, "");
} else {
Tcl_DStringAppendElement(&dString,
containerPtr->embeddedPtr->pathName);
}
Tcl_DStringEndSublist(&dString);
}
Tcl_DStringResult(interp, &dString);
return TCL_OK;
}
int AsnMemberDesc::TclGetDesc (Tcl_DString *desc) const
{
if (name)
{
Tcl_DStringStartSublist (desc);
Tcl_DStringAppendElement (desc, (char*)name);
this->desc->AsnTypeDesc::TclGetDesc (desc);
TclGetDesc2 (desc);
Tcl_DStringEndSublist (desc);
return TCL_OK;
}
else
return TCL_BREAK;
}
/* Provide mechanism for simulator to report which instruction
is being executed */
void report_pc(unsigned pc)
{
int status;
char addr[10];
char code[12];
Tcl_DString cmd;
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, "simLabel ", -1);
Tcl_DStringStartSublist(&cmd);
sprintf(addr, "%u", pc);
Tcl_DStringAppendElement(&cmd, addr);
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
sprintf(code, "%s","*");
Tcl_DStringAppend(&cmd, code, -1);
Tcl_DStringEndSublist(&cmd);
status = Tcl_Eval(sim_interp, Tcl_DStringValue(&cmd));
if (status != TCL_OK) {
fprintf(stderr, "Failed to report code '%s'\n", code);
fprintf(stderr, "Error Message was '%s'\n", sim_interp->result);
}
}
static void dgsprintxy(Tcl_DString * result, int npts, point p[])
{
int i;
char buf[20];
if (npts != 1)
Tcl_DStringStartSublist(result);
for (i = 0; i < npts; i++) {
sprintf(buf, "%g", p[i].x);
Tcl_DStringAppendElement(result, buf);
sprintf(buf, "%g", p[i].y);
Tcl_DStringAppendElement(result, buf);
}
if (npts != 1)
Tcl_DStringEndSublist(result);
}
void
NsAppendConn(Tcl_DString *dsPtr, Conn *connPtr, char *state)
{
Ns_Time now, diff;
Ns_GetTime(&now);
Ns_DiffTime(&now, &connPtr->times.queue, &diff);
Tcl_DStringStartSublist(dsPtr);
Ns_DStringPrintf(dsPtr, "%d", connPtr->id);
Tcl_DStringAppendElement(dsPtr, Ns_ConnPeer((Ns_Conn *) connPtr));
Tcl_DStringAppendElement(dsPtr, state);
NsAppendRequest(dsPtr, connPtr->request);
Ns_DStringPrintf(dsPtr, " %ld.%ld %d",
diff.sec, diff.usec, connPtr->nContentSent);
Tcl_DStringEndSublist(dsPtr);
}
void
Ns_MutexList(Tcl_DString *dsPtr)
{
Mutex *mutexPtr;
char buf[100];
Ns_MasterLock();
mutexPtr = firstMutexPtr;
while (mutexPtr != NULL) {
Tcl_DStringStartSublist(dsPtr);
Tcl_DStringAppendElement(dsPtr, mutexPtr->name);
Tcl_DStringAppendElement(dsPtr, "");
sprintf(buf, " %d %lu %lu", mutexPtr->id, mutexPtr->nlock, mutexPtr->nbusy);
Tcl_DStringAppend(dsPtr, buf, -1);
Tcl_DStringEndSublist(dsPtr);
mutexPtr = mutexPtr->nextPtr;
}
Ns_MasterUnlock();
}
char*
Tnm_SnmpMergeVBList(int varBindSize, SNMP_VarBind *varBindPtr)
{
static Tcl_DString list;
int i;
Tcl_DStringInit(&list);
for (i = 0; i < varBindSize; i++) {
Tcl_DStringStartSublist(&list);
Tcl_DStringAppendElement(&list,
varBindPtr[i].soid ? varBindPtr[i].soid : "");
Tcl_DStringAppendElement(&list,
varBindPtr[i].syntax ? varBindPtr[i].syntax : "");
Tcl_DStringAppendElement(&list,
varBindPtr[i].value ? varBindPtr[i].value : "");
Tcl_DStringEndSublist(&list);
}
return ckstrdup(Tcl_DStringValue(&list));
}
static void
ExpandItemList(
TreeCtrl *tree, /* Widget info. */
TreeItemList *itemList, /* list of item IDs */
Tcl_DString *result /* Gets appended. Caller must initialize. */
)
{
if (itemList == NULL) {
Tcl_DStringAppend(result, "{}", 2);
} else {
int i, count;
char buf[10 + TCL_INTEGER_SPACE];
Tcl_DStringStartSublist(result);
count = TreeItemList_Count(itemList);
for (i = 0; i < count; i++) {
(void) sprintf(buf, "%s%d",
(tree->itemPrefixLen ? tree->itemPrefix : ""),
TreeItem_GetID(tree, TreeItemList_Nth(itemList, i)));
Tcl_DStringAppendElement(result, buf);
}
Tcl_DStringEndSublist(result);
}
}
static int
TcpGetOptionProc(
ClientData instanceData, /* Socket state. */
Tcl_Interp *interp, /* For error reporting - can be NULL. */
const char *optionName, /* Name of the option to retrieve the value
* for, or NULL to get all options and their
* values. */
Tcl_DString *dsPtr) /* Where to store the computed value;
* initialized by caller. */
{
TcpState *statePtr = instanceData;
size_t len = 0;
WaitForConnect(statePtr, NULL);
if (optionName != NULL) {
len = strlen(optionName);
}
if ((len > 1) && (optionName[1] == 'e') &&
(strncmp(optionName, "-error", len) == 0)) {
socklen_t optlen = sizeof(int);
if (statePtr->flags & TCP_ASYNC_CONNECT) {
/* Suppress errors as long as we are not done */
errno = 0;
} else if (statePtr->connectError != 0) {
errno = statePtr->connectError;
statePtr->connectError = 0;
} else {
int err;
getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR,
(char *) &err, &optlen);
errno = err;
}
if (errno != 0) {
Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(errno), -1);
}
return TCL_OK;
}
if ((len > 1) && (optionName[1] == 'c') &&
(strncmp(optionName, "-connecting", len) == 0)) {
Tcl_DStringAppend(dsPtr,
(statePtr->flags & TCP_ASYNC_CONNECT) ? "1" : "0", -1);
return TCL_OK;
}
if ((len == 0) || ((len > 1) && (optionName[1] == 'p') &&
(strncmp(optionName, "-peername", len) == 0))) {
address peername;
socklen_t size = sizeof(peername);
if ( (statePtr->flags & TCP_ASYNC_CONNECT) ) {
/*
* In async connect output an empty string
*/
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-peername");
Tcl_DStringAppendElement(dsPtr, "");
} else {
return TCL_OK;
}
} else if (getpeername(statePtr->fds.fd, &peername.sa, &size) >= 0) {
/*
* Peername fetch succeeded - output list
*/
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-peername");
Tcl_DStringStartSublist(dsPtr);
}
TcpHostPortList(interp, dsPtr, peername, size);
if (len) {
return TCL_OK;
}
Tcl_DStringEndSublist(dsPtr);
} else {
/*
* getpeername failed - but if we were asked for all the options
* (len==0), don't flag an error at that point because it could be
* an fconfigure request on a server socket (which have no peer).
* Same must be done on win&mac.
*/
if (len) {
if (interp) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't get peername: %s",
Tcl_PosixError(interp)));
}
return TCL_ERROR;
}
}
}
if ((len == 0) || ((len > 1) && (optionName[1] == 's') &&
(strncmp(optionName, "-sockname", len) == 0))) {
TcpFdList *fds;
address sockname;
socklen_t size;
int found = 0;
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-sockname");
Tcl_DStringStartSublist(dsPtr);
}
if ( (statePtr->flags & TCP_ASYNC_CONNECT) ) {
/*
* In async connect output an empty string
*/
found = 1;
} else {
for (fds = &statePtr->fds; fds != NULL; fds = fds->next) {
size = sizeof(sockname);
if (getsockname(fds->fd, &(sockname.sa), &size) >= 0) {
found = 1;
TcpHostPortList(interp, dsPtr, sockname, size);
}
}
}
if (found) {
if (len) {
return TCL_OK;
}
Tcl_DStringEndSublist(dsPtr);
} else {
if (interp) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't get sockname: %s", Tcl_PosixError(interp)));
}
return TCL_ERROR;
}
}
if (len > 0) {
return Tcl_BadChannelOption(interp, optionName, "connecting peername sockname");
}
return TCL_OK;
}
/*
** This routine adds information to the input texts that doesn't change
** when the display is resized or when new fonts are selected, etc.
** Mostly this means adding style attributes. But other constant
** information (such as numbering on <li> and images used for <IMG>)
** is also obtained. The key is that this routine is only called
** once, where the sizer and layout routines can be called many times.
**
** This routine is called whenever the list of elements grows. The
** style stack is stored as part of the HTML widget so that we can
** always continue where we left off the last time.
**
** In addition to adding style, this routine will invoke callbacks
** needed to acquire information about a markup. The htmlPtr->zIsVisitied
** callback is called for each <a> and the htmlPtr->zGetImage is called
** for each <IMG> or for each <LI> that has a SRC= field.
**
** This routine may invoke a callback procedure which could delete
** the HTML widget.
**
** When a markup is inserted or deleted from the token list, the
** style routine must be completely rerun from the beginning. So
** what we said above, that this routine is only run once, is not
** strictly true.
*/
void HtmlAddStyle(HtmlWidget *htmlPtr, HtmlElement *p){
HtmlStyle style; /* Current style */
int size; /* A new font size */
int i; /* Loop counter */
int paraAlign; /* Current paragraph alignment */
int rowAlign; /* Current table row alignment */
int anchorFlags; /* Flags associated with <a> tag */
int inDt; /* True if within <dt>..</dt> */
HtmlStyle nextStyle; /* Style for next token if useNextStyle==1 */
int useNextStyle = 0; /* True if nextStyle is valid */
char *z; /* A tag parameter's value */
/* The size of header fonts relative to the current font size */
static int header_sizes[] = {+2, +1, 1, 1, -1, -1};
/* Don't allow recursion */
if( htmlPtr->flags & STYLER_RUNNING ){ TestPoint(0); return; }
htmlPtr->flags |= STYLER_RUNNING;
/* Load the style state out of the htmlPtr structure and into local
** variables. This is purely a matter of convenience... */
style = GetCurrentStyle(htmlPtr);
paraAlign = htmlPtr->paraAlignment;
rowAlign = htmlPtr->rowAlignment;
anchorFlags = htmlPtr->anchorFlags;
inDt = htmlPtr->inDt;
/* Loop over tokens */
while( p ){
switch( p->base.type ){
case Html_A:
if( htmlPtr->anchorStart ){
style = HtmlPopStyleStack(htmlPtr, Html_EndA);
htmlPtr->anchorStart = 0;
anchorFlags = 0;
}
z = HtmlMarkupArg(p,"href",0);
if( z ){
HtmlLock(htmlPtr);
style.color = GetLinkColor(htmlPtr, z);
if( htmlPtr->underlineLinks ){
style.flags |= STY_Underline;
}
if( HtmlUnlock(htmlPtr) ) return;
anchorFlags |= STY_Anchor;
PushStyleStack(htmlPtr, Html_EndA, style);
htmlPtr->anchorStart = p;
}
break;
case Html_EndA:
if( htmlPtr->anchorStart ){
p->ref.pOther = htmlPtr->anchorStart;
style = HtmlPopStyleStack(htmlPtr, Html_EndA);
htmlPtr->anchorStart = 0;
anchorFlags = 0;
}
break;
case Html_ADDRESS:
case Html_EndADDRESS:
case Html_BLOCKQUOTE:
case Html_EndBLOCKQUOTE:
paraAlign = ALIGN_None;
TestPoint(0);
break;
case Html_APPLET:
if( htmlPtr->zAppletCommand && *htmlPtr->zAppletCommand ){
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndAPPLET, nextStyle);
useNextStyle = 1;
}else{
PushStyleStack(htmlPtr, Html_EndAPPLET, style);
}
TestPoint(0);
break;
case Html_B:
style.font = BoldFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndB, style);
TestPoint(0);
break;
case Html_EndAPPLET:
case Html_EndB:
case Html_EndBIG:
case Html_EndCENTER:
case Html_EndCITE:
case Html_EndCODE:
case Html_EndCOMMENT:
case Html_EndEM:
case Html_EndFONT:
case Html_EndI:
case Html_EndKBD:
case Html_EndMARQUEE:
case Html_EndNOBR:
case Html_EndNOFRAME:
case Html_EndNOSCRIPT:
case Html_EndS:
case Html_EndSAMP:
case Html_EndSMALL:
case Html_EndSTRIKE:
case Html_EndSTRONG:
case Html_EndSUB:
case Html_EndSUP:
case Html_EndTITLE:
case Html_EndTT:
case Html_EndU:
case Html_EndVAR:
style = HtmlPopStyleStack(htmlPtr, p->base.type);
TestPoint(0);
break;
case Html_BASE:
z = HtmlMarkupArg(p,"href",0);
if( z ){
HtmlLock(htmlPtr);
z = HtmlResolveUri(htmlPtr, z);
if( HtmlUnlock(htmlPtr) ) return;
if( z!=0 ){
if( htmlPtr->zBaseHref ){
HtmlFree(htmlPtr->zBaseHref);
}
htmlPtr->zBaseHref = z;
}
}
break;
case Html_EndDIV:
paraAlign = ALIGN_None;
style = HtmlPopStyleStack(htmlPtr, p->base.type);
TestPoint(0);
break;
case Html_EndBASEFONT:
style = HtmlPopStyleStack(htmlPtr, Html_EndBASEFONT);
style.font = FontFamily(style.font) + 2;
TestPoint(0);
break;
case Html_BIG:
ScaleFont(&style,1);
PushStyleStack(htmlPtr, Html_EndBIG, style);
TestPoint(0);
break;
case Html_CAPTION:
paraAlign = GetAlignment(p, paraAlign);
TestPoint(0);
break;
case Html_EndCAPTION:
paraAlign = ALIGN_None;
TestPoint(0);
break;
case Html_CENTER:
paraAlign = ALIGN_None;
style.align = ALIGN_Center;
PushStyleStack(htmlPtr, Html_EndCENTER, style);
TestPoint(0);
break;
case Html_CITE:
PushStyleStack(htmlPtr, Html_EndCITE, style);
TestPoint(0);
break;
case Html_CODE:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndCODE, style);
TestPoint(0);
break;
case Html_COMMENT:
style.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndCOMMENT, style);
TestPoint(0);
break;
case Html_DD:
if( htmlPtr->innerList && htmlPtr->innerList->base.type==Html_DL ){
p->ref.pOther = htmlPtr->innerList;
TestPoint(0);
}else{
p->ref.pOther = 0;
TestPoint(0);
}
inDt = 0;
break;
case Html_DIR:
case Html_MENU:
case Html_UL:
p->list.pPrev = htmlPtr->innerList;
p->list.cnt = 0;
htmlPtr->innerList = p;
if( p->list.pPrev==0 ){
p->list.type = LI_TYPE_Bullet1;
p->list.compact = HtmlMarkupArg(p,"compact",0)!=0;
TestPoint(0);
}else if( p->list.pPrev->list.pPrev==0 ){
p->list.type = LI_TYPE_Bullet2;
p->list.compact = 1;
TestPoint(0);
}else{
p->list.type = LI_TYPE_Bullet3;
p->list.compact = 1;
TestPoint(0);
}
p->list.type = GetUnorderedListType(p,p->list.type);
break;
case Html_EndDL:
inDt = 0;
TestPoint(0);
/* Fall thru into the next case */
case Html_EndDIR:
case Html_EndMENU:
case Html_EndOL:
case Html_EndUL:
p->ref.pOther = htmlPtr->innerList;
if( htmlPtr->innerList ){
htmlPtr->innerList = htmlPtr->innerList->list.pPrev;
TestPoint(0);
}else{
TestPoint(0);
}
break;
case Html_DIV:
paraAlign = ALIGN_None;
style.align = GetAlignment(p, style.align);
PushStyleStack(htmlPtr, Html_EndDIV, style);
TestPoint(0);
break;
case Html_DT:
if( htmlPtr->innerList && htmlPtr->innerList->base.type==Html_DL ){
p->ref.pOther = htmlPtr->innerList;
TestPoint(0);
}else{
p->ref.pOther = 0;
TestPoint(0);
}
inDt = STY_DT;
break;
case Html_EndDD:
case Html_EndDT:
inDt = 0;
TestPoint(0);
break;
case Html_DL:
p->list.pPrev = htmlPtr->innerList;
p->list.cnt = 0;
htmlPtr->innerList = p;
p->list.compact = HtmlMarkupArg(p,"compact",0)!=0;
inDt = 0;
TestPoint(0);
break;
case Html_EM:
style.font = ItalicFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndEM, style);
TestPoint(0);
break;
case Html_EMBED:
break;
case Html_BASEFONT:
case Html_FONT:
z = HtmlMarkupArg(p,"size",0);
if( z ){
if( *z=='-' ){
size = FontSize(style.font) - atoi(&z[1]);
}else if( *z=='+' ){
size = FontSize(style.font) + atoi(&z[1]);
}else{
size = atoi(z);
}
if( size <= 0 ){
size = 1;
}
if( size >= N_FONT_SIZE ){
size = N_FONT_SIZE - 1;
}
style.font = FontFamily(style.font) + size - 1;
}
z = HtmlMarkupArg(p,"color",0);
if( z ){
style.color = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr,
p->base.type==Html_FONT ? Html_EndFONT : Html_EndBASEFONT, style);
break;
case Html_FORM: {
char *zUrl;
char *zMethod;
Tcl_DString cmd; /* -formcommand callback */
int result;
char zToken[50];
htmlPtr->formStart = 0;
p->form.id = 0;
if( htmlPtr->zFormCommand==0 || htmlPtr->zFormCommand[0]==0 ){
TestPoint(0);
break;
}
zUrl = HtmlMarkupArg(p,"action",0);
if( zUrl==0 ){
TestPoint(0);
break;
}
HtmlLock(htmlPtr);
zUrl = HtmlResolveUri(htmlPtr, zUrl);
if( HtmlUnlock(htmlPtr) ) return;
if( zUrl==0 ) break;
zMethod = HtmlMarkupArg(p,"method","GET");
sprintf(zToken," %d form ", ++htmlPtr->nForm);
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
Tcl_DStringAppend(&cmd, zToken, -1);
Tcl_DStringAppendElement(&cmd, zUrl);
HtmlFree(zUrl);
Tcl_DStringAppendElement(&cmd, zMethod);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, p);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( HtmlUnlock(htmlPtr) ) return;
if( result==TCL_OK ){
htmlPtr->formStart = p;
p->form.id = htmlPtr->nForm;
}
Tcl_ResetResult(htmlPtr->interp);
break;
}
case Html_EndFORM:
p->ref.pOther = htmlPtr->formStart;
htmlPtr->formStart = 0;
TestPoint(0);
break;
case Html_H1:
case Html_H2:
case Html_H3:
case Html_H4:
case Html_H5:
case Html_H6:
paraAlign = ALIGN_None;
i = (p->base.type - Html_H1)/2 + 1;
if( i>=1 && i<=6 ){
ScaleFont(&style,header_sizes[i-1]);
}
style.font = BoldFont( FontSize(style.font) );
style.align = GetAlignment(p, style.align);
PushStyleStack(htmlPtr, Html_EndH1, style);
break;
case Html_EndH1:
case Html_EndH2:
case Html_EndH3:
case Html_EndH4:
case Html_EndH5:
case Html_EndH6:
paraAlign = ALIGN_None;
style = HtmlPopStyleStack(htmlPtr, Html_EndH1);
TestPoint(0);
break;
case Html_HR:
nextStyle = style;
style.align = GetAlignment(p, ALIGN_None);
useNextStyle = 1;
break;
case Html_I:
style.font = ItalicFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndI, style);
TestPoint(0);
break;
case Html_IMG:
HtmlLock(htmlPtr);
p->image.pImage = HtmlGetImage(htmlPtr, p);
if( HtmlUnlock(htmlPtr) ) return;
TestPoint(0);
break;
case Html_INPUT:
p->input.pForm = htmlPtr->formStart;
TestPoint(0);
break;
case Html_KBD:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndKBD, style);
TestPoint(0);
break;
case Html_LI:
if( htmlPtr->innerList ){
p->li.type = htmlPtr->innerList->list.type;
if( htmlPtr->innerList->base.type==Html_OL ){
z = HtmlMarkupArg(p, "value", 0);
if( z ){
int n = atoi(z);
if( n>0 ){
p->li.cnt = n;
htmlPtr->innerList->list.cnt = n+1;
TestPoint(0);
}else{
TestPoint(0);
}
}else{
p->li.cnt = htmlPtr->innerList->list.cnt++;
TestPoint(0);
}
p->li.type = GetOrderedListType(p,p->li.type);
}else{
p->li.type = GetUnorderedListType(p,p->li.type);
TestPoint(0);
}
}else{
p->base.flags &= ~HTML_Visible;
TestPoint(0);
}
break;
case Html_MARQUEE:
style.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndMARQUEE, style);
TestPoint(0);
break;
case Html_NOBR:
style.flags |= STY_NoBreak;
PushStyleStack(htmlPtr, Html_EndNOBR, style);
TestPoint(0);
break;
case Html_NOFRAME:
if( htmlPtr->zFrameCommand && *htmlPtr->zFrameCommand ){
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndNOFRAME, nextStyle);
useNextStyle = 1;
}else{
PushStyleStack(htmlPtr, Html_EndNOFRAME, style);
}
TestPoint(0);
break;
case Html_NOSCRIPT:
if( htmlPtr->zScriptCommand && *htmlPtr->zScriptCommand ){
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndNOSCRIPT, nextStyle);
useNextStyle = 1;
}else{
PushStyleStack(htmlPtr, Html_EndNOSCRIPT, style);
}
TestPoint(0);
break;
case Html_OL:
p->list.pPrev = htmlPtr->innerList;
p->list.type = GetOrderedListType(p,LI_TYPE_Enum_1);
p->list.cnt = 1;
z = HtmlMarkupArg(p,"start",0);
if( z ){
int n = atoi(z);
if( n>0 ){
p->list.cnt = n;
TestPoint(0);
}else{
TestPoint(0);
}
}else{
TestPoint(0);
}
p->list.compact = htmlPtr->innerList!=0 ||
HtmlMarkupArg(p,"compact",0)!=0;
htmlPtr->innerList = p;
break;
case Html_P:
paraAlign = GetAlignment(p, ALIGN_None);
TestPoint(0);
break;
case Html_EndP:
paraAlign = ALIGN_None;
TestPoint(0);
break;
case Html_PRE:
case Html_LISTING:
case Html_XMP:
case Html_PLAINTEXT:
paraAlign = ALIGN_None;
style.font = CWFont( FontSize(style.font) );
style.flags |= STY_Preformatted;
PushStyleStack(htmlPtr, Html_EndPRE, style);
TestPoint(0);
break;
case Html_EndPRE:
case Html_EndLISTING:
case Html_EndXMP:
style = HtmlPopStyleStack(htmlPtr, Html_EndPRE);
TestPoint(0);
break;
case Html_S:
style.flags |= STY_StrikeThru;
PushStyleStack(htmlPtr, Html_EndS, style);
TestPoint(0);
break;
case Html_SCRIPT:
if( htmlPtr->zScriptCommand && *htmlPtr->zScriptCommand ){
Tcl_DString cmd;
int result;
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zScriptCommand, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, p);
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
Tcl_DStringAppend(&cmd, p->script.zScript, p->script.nScript);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( HtmlUnlock(htmlPtr) ) return;
Tcl_ResetResult(htmlPtr->interp);
}
nextStyle = style;
style.flags |= STY_Invisible;
useNextStyle = 1;
break;
case Html_SELECT:
p->input.pForm = htmlPtr->formStart;
nextStyle.flags |= STY_Invisible;
useNextStyle = 1;
PushStyleStack(htmlPtr, Html_EndSELECT, style);
htmlPtr->formElemStart = p;
break;
case Html_EndSELECT:
style = HtmlPopStyleStack(htmlPtr, Html_EndSELECT);
if( htmlPtr->formElemStart
&& htmlPtr->formElemStart->base.type==Html_SELECT ){
p->ref.pOther = htmlPtr->formElemStart;
MakeInvisible(p->ref.pOther, p);
}else{
p->ref.pOther = 0;
}
htmlPtr->formElemStart = 0;
break;
case Html_STRIKE:
style.flags |= STY_StrikeThru;
PushStyleStack(htmlPtr, Html_EndSTRIKE, style);
TestPoint(0);
break;
case Html_STYLE:
/* Ignore style sheets */
break;
case Html_SAMP:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndSAMP, style);
TestPoint(0);
break;
case Html_SMALL:
ScaleFont(&style,-1);
PushStyleStack(htmlPtr, Html_EndSMALL, style);
TestPoint(0);
break;
case Html_STRONG:
style.font = BoldFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndSTRONG, style);
TestPoint(0);
break;
case Html_SUB:
ScaleFont(&style,-1);
if( style.subscript > -6 ){
style.subscript--;
TestPoint(0);
}else{
TestPoint(0);
}
PushStyleStack(htmlPtr, Html_EndSUB, style);
break;
case Html_SUP:
ScaleFont(&style,-1);
if( style.subscript < 6 ){
style.subscript++;
TestPoint(0);
}else{
TestPoint(0);
}
PushStyleStack(htmlPtr, Html_EndSUP, style);
break;
case Html_TABLE:
paraAlign = ALIGN_None;
nextStyle = style;
nextStyle.align = ALIGN_Left;
z = HtmlMarkupArg(p, "bgcolor", 0);
if( z ){
nextStyle.bgcolor = HtmlGetColorByName(htmlPtr, z);
style.bgcolor = nextStyle.bgcolor;
/* }else{
nextStyle.bgcolor = COLOR_Background; */
}
PushStyleStack(htmlPtr, Html_EndTABLE, nextStyle);
useNextStyle = 1;
htmlPtr->inTd = 0;
htmlPtr->inTr = 0;
TestPoint(0);
break;
case Html_EndTABLE:
paraAlign = ALIGN_None;
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
}
if( htmlPtr->inTr ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTR);
htmlPtr->inTr = 0;
}
style = HtmlPopStyleStack(htmlPtr, p->base.type);
TestPoint(0);
break;
case Html_TD:
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
}
htmlPtr->inTd = 1;
paraAlign = GetAlignment(p, rowAlign);
if( (z = HtmlMarkupArg(p, "bgcolor", 0))!=0 ){
style.bgcolor = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr, Html_EndTD, style);
TestPoint(0);
break;
case Html_TEXTAREA:
p->input.pForm = htmlPtr->formStart;
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndTEXTAREA, nextStyle);
htmlPtr->formElemStart = p;
useNextStyle = 1;
TestPoint(0);
break;
case Html_EndTEXTAREA:
style = HtmlPopStyleStack(htmlPtr, Html_EndTEXTAREA);
if( htmlPtr->formElemStart
&& htmlPtr->formElemStart->base.type==Html_TEXTAREA ){
p->ref.pOther = htmlPtr->formElemStart;
}else{
p->ref.pOther = 0;
}
htmlPtr->formElemStart = 0;
break;
case Html_TH:
/* paraAlign = GetAlignment(p, rowAlign); */
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
}
paraAlign = GetAlignment(p, ALIGN_Center);
style.font = BoldFont( FontSize(style.font) );
if( (z = HtmlMarkupArg(p, "bgcolor", 0))!=0 ){
style.bgcolor = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr, Html_EndTD, style);
htmlPtr->inTd = 1;
TestPoint(0);
break;
case Html_TR:
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
}
if( htmlPtr->inTr ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTR);
}
rowAlign = GetAlignment(p, ALIGN_None);
if( (z = HtmlMarkupArg(p, "bgcolor", 0))!=0 ){
style.bgcolor = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr, Html_EndTR, style);
htmlPtr->inTr = 1;
TestPoint(0);
break;
case Html_EndTR:
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
}
style = HtmlPopStyleStack(htmlPtr, Html_EndTR);
htmlPtr->inTr = 0;
paraAlign = ALIGN_None;
rowAlign = ALIGN_None;
TestPoint(0);
break;
case Html_EndTD:
case Html_EndTH:
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
paraAlign = ALIGN_None;
rowAlign = ALIGN_None;
TestPoint(0);
break;
case Html_TITLE:
style.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndTITLE, style);
TestPoint(0);
break;
case Html_TT:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndTT, style);
TestPoint(0);
break;
case Html_U:
style.flags |= STY_Underline;
PushStyleStack(htmlPtr, Html_EndU, style);
break;
case Html_VAR:
style.font = ItalicFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndVAR, style);
TestPoint(0);
break;
default:
TestPoint(0);
break;
}
p->base.style = style;
p->base.style.flags |= anchorFlags | inDt;
if( paraAlign!=ALIGN_None ){
p->base.style.align = paraAlign;
}
if( useNextStyle ){
style = nextStyle;
useNextStyle = 0;
}
TRACE(HtmlTrace_Style,
("Style of 0x%08x font=%02d color=%02d bg=%02d "
"align=%d flags=0x%04x token=%s\n",
(int)p, p->base.style.font, p->base.style.color, p->base.style.bgcolor,
p->base.style.align, p->base.style.flags, HtmlTokenName(p)));
p = p->pNext;
}
/* Copy state information back into the htmlPtr structure for
** safe keeping. */
htmlPtr->paraAlignment = paraAlign;
htmlPtr->rowAlignment = rowAlign;
htmlPtr->anchorFlags = anchorFlags;
htmlPtr->inDt = inDt;
htmlPtr->flags &= ~STYLER_RUNNING;
}
static int
TtyGetOptionProc(
ClientData instanceData, /* File state. */
Tcl_Interp *interp, /* For error reporting - can be NULL. */
const char *optionName, /* Option to get. */
Tcl_DString *dsPtr) /* Where to store value(s). */
{
FileState *fsPtr = instanceData;
unsigned int len;
char buf[3*TCL_INTEGER_SPACE + 16];
int valid = 0; /* Flag if valid option parsed. */
if (optionName == NULL) {
len = 0;
} else {
len = strlen(optionName);
}
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-mode");
}
if (len==0 || (len>2 && strncmp(optionName, "-mode", len)==0)) {
TtyAttrs tty;
valid = 1;
TtyGetAttributes(fsPtr->fd, &tty);
sprintf(buf, "%d,%c,%d,%d", tty.baud, tty.parity, tty.data, tty.stop);
Tcl_DStringAppendElement(dsPtr, buf);
}
/*
* Get option -xchar
*/
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-xchar");
Tcl_DStringStartSublist(dsPtr);
}
if (len==0 || (len>1 && strncmp(optionName, "-xchar", len)==0)) {
struct termios iostate;
Tcl_DString ds;
valid = 1;
tcgetattr(fsPtr->fd, &iostate);
Tcl_DStringInit(&ds);
Tcl_ExternalToUtfDString(NULL, (char *) &iostate.c_cc[VSTART], 1, &ds);
Tcl_DStringAppendElement(dsPtr, Tcl_DStringValue(&ds));
TclDStringClear(&ds);
Tcl_ExternalToUtfDString(NULL, (char *) &iostate.c_cc[VSTOP], 1, &ds);
Tcl_DStringAppendElement(dsPtr, Tcl_DStringValue(&ds));
Tcl_DStringFree(&ds);
}
if (len == 0) {
Tcl_DStringEndSublist(dsPtr);
}
/*
* Get option -queue
* Option is readonly and returned by [fconfigure chan -queue] but not
* returned by unnamed [fconfigure chan].
*/
if ((len > 1) && (strncmp(optionName, "-queue", len) == 0)) {
int inQueue=0, outQueue=0, inBuffered, outBuffered;
valid = 1;
GETREADQUEUE(fsPtr->fd, inQueue);
GETWRITEQUEUE(fsPtr->fd, outQueue);
inBuffered = Tcl_InputBuffered(fsPtr->channel);
outBuffered = Tcl_OutputBuffered(fsPtr->channel);
sprintf(buf, "%d", inBuffered+inQueue);
Tcl_DStringAppendElement(dsPtr, buf);
sprintf(buf, "%d", outBuffered+outQueue);
Tcl_DStringAppendElement(dsPtr, buf);
}
#if defined(TIOCMGET)
/*
* Get option -ttystatus
* Option is readonly and returned by [fconfigure chan -ttystatus] but not
* returned by unnamed [fconfigure chan].
*/
if ((len > 4) && (strncmp(optionName, "-ttystatus", len) == 0)) {
int status;
valid = 1;
ioctl(fsPtr->fd, TIOCMGET, &status);
TtyModemStatusStr(status, dsPtr);
}
#endif /* TIOCMGET */
if (valid) {
return TCL_OK;
}
return Tcl_BadChannelOption(interp, optionName, "mode"
" queue ttystatus xchar"
);
}
/* Process as much of the input HTML as possible. Construct new
** HtmlElement structures and appended them to the list. Return
** the number of characters actually processed.
**
** This routine may invoke a callback procedure which could delete
** the HTML widget.
**
** This routine is not reentrant for the same HTML widget. To
** prevent reentrancy (during a callback), the p->iCol field is
** set to a negative number. This is a flag to future invocations
** not to reentry this routine. The p->iCol field is restored
** before exiting, of course.
*/
static int Tokenize(
HtmlWidget *p /* The HTML widget doing the parsing */
){
char *z; /* The input HTML text */
int c; /* The next character of input */
int n; /* Number of characters processed so far */
int iCol; /* Column of input */
int i, j; /* Loop counters */
int h; /* Result from HtmlHash() */
int nByte; /* Space allocated for a single HtmlElement */
HtmlElement *pElem; /* A new HTML element */
int selfClose; /* True for content free elements. Ex: <br/> */
int argc; /* The number of arguments on a markup */
HtmlTokenMap *pMap; /* For searching the markup name hash table */
char *zBuf; /* For handing out buffer space */
# define mxARG 200 /* Maximum number of parameters in a single markup */
char *argv[mxARG]; /* Pointers to each markup argument. */
int arglen[mxARG]; /* Length of each markup argument */
iCol = p->iCol;
n = p->nComplete;
z = p->zText;
if( iCol<0 ){ TestPoint(0); return n; } /* Prevents recursion */
p->iCol = -1;
while( (c=z[n])!=0 ){
if( p->pScript ){
/* We are in the middle of <SCRIPT>...</SCRIPT>. Just look for
** the </SCRIPT> markup. (later:) Treat <STYLE>...</STYLE> the
** same way. */
HtmlScript *pScript = p->pScript;
char *zEnd;
int nEnd;
if( pScript->markup.base.type==Html_SCRIPT ){
zEnd = "</script>";
nEnd = 9;
}else{
zEnd = "</style>";
nEnd = 8;
}
if( pScript->zScript==0 ){
pScript->zScript = &z[n];
pScript->nScript = 0;
}
for(i=n+pScript->nScript; z[i]; i++){
if( z[i]=='<' && z[i+1]=='/' && strnicmp(&z[i],zEnd,nEnd)==0 ){
pScript->nScript = i - n;
p->pScript = 0;
n = i+nEnd;
break;
}
}
if( p->pScript ){
pScript->nScript = i - n;
}
continue;
}else if( isspace(c) ){
/* White space */
for(i=0; (c=z[n+i])!=0 && isspace(c) && c!='\n' && c!='\r'; i++){}
if( c=='\r' && z[n+i+1]=='\n' ){ i++; }
pElem = HtmlAlloc( sizeof(HtmlSpaceElement) );
if( pElem==0 ){ goto incomplete; }
pElem->base.type = Html_Space;
if( c=='\n' || c=='\r' ){
pElem->base.flags = HTML_NewLine;
pElem->base.count = 1;
i++;
iCol = 0;
TestPoint(0);
}else{
int iColStart = iCol;
pElem->base.flags = 0;
for(j=0; j<i; j++){
iCol = NextColumn(iCol, z[n+j]);
TestPoint(0);
}
pElem->base.count = iCol - iColStart;
}
AppendElement(p,pElem);
n += i;
}else if( c!='<' || p->iPlaintext!=0 ||
(!isalpha(z[n+1]) && z[n+1]!='/' && z[n+1]!='!' && z[n+1]!='?') ){
/* Ordinary text */
for(i=1; (c=z[n+i])!=0 && !isspace(c) && c!='<'; i++){}
if( c==0 ){ TestPoint(0); goto incomplete; }
if( p->iPlaintext!=0 && z[n]=='<' ){
switch( p->iPlaintext ){
case Html_LISTING:
if( i>=10 && strnicmp(&z[n],"</listing>",10)==0 ){
p->iPlaintext = 0;
goto doMarkup;
}
break;
case Html_XMP:
if( i>=6 && strnicmp(&z[n],"</xmp>",6)==0 ){
p->iPlaintext = 0;
goto doMarkup;
}
break;
case Html_TEXTAREA:
if( i>=11 && strnicmp(&z[n],"</textarea>",11)==0 ){
p->iPlaintext = 0;
goto doMarkup;
}
break;
default:
break;
}
}
nByte = sizeof(HtmlTextElement) + i;
pElem = HtmlAlloc( nByte );
if( pElem==0 ){ goto incomplete; }
memset(pElem,0,nByte);
pElem->base.type = Html_Text;
sprintf(pElem->text.zText,"%.*s",i,&z[n]);
AppendElement(p,pElem);
if( p->iPlaintext==0 || p->iPlaintext==Html_TEXTAREA ){
HtmlTranslateEscapes(pElem->text.zText);
}
pElem->base.count = strlen(pElem->text.zText);
n += i;
iCol += i;
}else if( strncmp(&z[n],"<!--",4)==0 ){
/* An HTML comment. Just skip it. */
for(i=4; z[n+i]; i++){
if( z[n+i]=='-' && strncmp(&z[n+i],"-->",3)==0 ){ break; }
}
if( z[n+i]==0 ){ TestPoint(0); goto incomplete; }
for(j=0; j<i+3; j++){
iCol = NextColumn(iCol, z[n+j]);
}
n += i + 3;
}else{
/* Markup.
**
** First get the name of the markup
*/
doMarkup:
argc = 1;
argv[0] = &z[n+1];
for(i=1; (c=z[n+i])!=0 && !isspace(c) && c!='>' && (i<2 || c!='/'); i++){}
arglen[0] = i - 1;
if( c==0 ){ goto incomplete; }
/*
** Now parse up the arguments
*/
while( isspace(z[n+i]) ){ i++; }
while( (c=z[n+i])!=0 && c!='>' && (c!='/' || z[n+i+1]!='>') ){
if( argc>mxARG-3 ){
argc = mxARG-3;
}
argv[argc] = &z[n+i];
j = 0;
while( (c=z[n+i+j])!=0 && !isspace(c) && c!='>'
&& c!='=' && (c!='/' || z[n+i+j+1]!='>') ){
j++;
}
arglen[argc] = j;
if( c==0 ){ goto incomplete; }
i += j;
while( isspace(c) ){
i++;
c = z[n+i];
}
if( c==0 ){ goto incomplete; }
argc++;
if( c!='=' ){
argv[argc] = "";
arglen[argc] = 0;
argc++;
continue;
}
i++;
c = z[n+i];
while( isspace(c) ){
i++;
c = z[n+i];
}
if( c==0 ){ goto incomplete; }
if( c=='\'' || c=='"' ){
int cQuote = c;
i++;
argv[argc] = &z[n+i];
for(j=0; (c=z[n+i+j])!=0 && c!=cQuote; j++){}
if( c==0 ){ goto incomplete; }
arglen[argc] = j;
i += j+1;
TestPoint(0);
}else{
argv[argc] = &z[n+i];
for(j=0; (c=z[n+i+j])!=0 && !isspace(c) && c!='>'; j++){}
if( c==0 ){ goto incomplete; }
arglen[argc] = j;
i += j;
}
argc++;
while( isspace(z[n+i]) ){ i++; }
}
if( c=='/' ){
i++;
c = z[n+i];
selfClose = 1;
}else{
selfClose = 0;
}
if( c==0 ){ goto incomplete; }
for(j=0; j<i+1; j++){
iCol = NextColumn(iCol, z[n+j]);
}
n += i + 1;
/* Lookup the markup name in the hash table
*/
if( !isInit ){
HtmlHashInit();
isInit = 1;
}
c = argv[0][arglen[0]];
argv[0][arglen[0]] = 0;
h = HtmlHash(argv[0]);
for(pMap = apMap[h]; pMap; pMap=pMap->pCollide){
if( stricmp(pMap->zName,argv[0])==0 ){ break; }
TestPoint(0);
}
argv[0][arglen[0]] = c;
if( pMap==0 ){ continue; } /* Ignore unknown markup */
makeMarkupEntry:
/* Construct a HtmlMarkup entry for this markup.
*/
if( pMap->extra ){
nByte = pMap->extra;
}else if( argc==1 ){
nByte = sizeof(HtmlBaseElement);
}else{
nByte = sizeof(HtmlMarkupElement);
}
if( argc>1 ){
nByte += sizeof(char*) * argc;
for(j=1; j<argc; j++){
nByte += arglen[j] + 1;
}
}
pElem = HtmlAlloc( nByte );
if( pElem==0 ){ goto incomplete; }
memset(pElem,0,nByte);
pElem->base.type = pMap->type;
pElem->base.count = argc - 1;
if( argc>1 ){
if( pMap->extra ){
pElem->markup.argv = (char**)&((char*)pElem)[pMap->extra];
}else{
pElem->markup.argv = (char**)&((HtmlMarkupElement*)pElem)[1];
}
zBuf = (char*)&pElem->markup.argv[argc];
for(j=1; j<argc; j++){
pElem->markup.argv[j-1] = zBuf;
zBuf += arglen[j] + 1;
sprintf(pElem->markup.argv[j-1],"%.*s",arglen[j],argv[j]);
HtmlTranslateEscapes(pElem->markup.argv[j-1]);
if( (j&1)==1 ){
ToLower(pElem->markup.argv[j-1]);
}
}
pElem->markup.argv[argc-1] = 0;
}
/* The new markup has now be constructed in pElem. But before
** appending to the list, check to see if there is a special
** handler for this markup type.
*/
if( p->zHandler[pMap->type] ){
Tcl_DString str;
Tcl_DStringInit(&str);
Tcl_DStringAppend(&str, p->zHandler[pMap->type], -1);
Tcl_DStringAppendElement(&str, pMap->zName);
Tcl_DStringStartSublist(&str);
for(j=0; j<argc-1; j++){
Tcl_DStringAppendElement(&str, pElem->markup.argv[j]);
}
Tcl_DStringEndSublist(&str);
HtmlFree(pElem);
HtmlLock(p);
Tcl_GlobalEval(p->interp, Tcl_DStringValue(&str));
Tcl_DStringFree(&str);
if( HtmlUnlock(p) ){ return 0; }
/* Tricky, tricky. The callback might have caused the p->zText
** pointer to change, so renew our copy of that pointer. The
** callback might also have cleared or destroyed the widget.
** If so, abort this routine.
*/
z = p->zText;
if( z==0 || p->tkwin==0 ){
n = 0;
iCol = 0;
goto incomplete;
}
continue;
}
/* No special handler for this markup. Just append it to the
** list of all tokens.
*/
AppendElement(p,pElem);
switch( pMap->type ){
case Html_PLAINTEXT:
case Html_LISTING:
case Html_XMP:
case Html_TEXTAREA:
p->iPlaintext = pMap->type;
break;
case Html_STYLE:
case Html_SCRIPT:
p->pScript = (HtmlScript*)pElem;
break;
default:
break;
}
/* If this is self-closing markup (ex: <br/> or <img/>) then
** synthesize a closing token.
*/
if( selfClose && argv[0][0]!='/'
&& strcmp(&pMap[1].zName[1],pMap->zName)==0 ){
selfClose = 0;
pMap++;
argc = 1;
goto makeMarkupEntry;
}
}
}
incomplete:
p->iCol = iCol;
return n;
}
/*
** Given an <IMG> markup, find or create an appropriate HtmlImage
** structure and return a pointer to that structure. NULL might
** be returned.
**
** This routine may invoke a callback procedure which could delete
** the HTML widget. Use HtmlLock() if necessary to preserve the
** widget structure.
*/
HtmlImage *HtmlGetImage(HtmlWidget *htmlPtr, HtmlElement *p){
char *zWidth;
char *zHeight;
char *zSrc;
const char *zImageName;
HtmlImage *pImage;
int result;
Tcl_DString cmd;
int lenSrc, lenW, lenH; /* Lengths of various strings */
if( p->base.type!=Html_IMG ){ CANT_HAPPEN; return 0; }
if( htmlPtr->zGetImage==0 || htmlPtr->zGetImage[0]==0 ){
TestPoint(0);
return 0;
}
zSrc = HtmlMarkupArg(p, "src", 0);
if( zSrc==0 ){
return 0;
}
HtmlLock(htmlPtr);
zSrc = HtmlResolveUri(htmlPtr, zSrc);
if( HtmlUnlock(htmlPtr) || zSrc==0 ) return 0;
zWidth = HtmlMarkupArg(p, "width", "");
zHeight = HtmlMarkupArg(p, "height", "");
for(pImage=htmlPtr->imageList; pImage; pImage=pImage->pNext){
if( strcmp(pImage->zUrl,zSrc)==0
&& strcmp(pImage->zWidth, zWidth)==0
&& strcmp(pImage->zHeight, zHeight)==0 ){
HtmlFree(zSrc);
return pImage;
}
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zGetImage, -1);
Tcl_DStringAppendElement(&cmd,zSrc);
Tcl_DStringAppendElement(&cmd,zWidth);
Tcl_DStringAppendElement(&cmd,zHeight);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, p);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( HtmlUnlock(htmlPtr) ){
HtmlFree(zSrc);
}
zImageName = Tcl_GetStringResult(htmlPtr->interp);
lenSrc = strlen(zSrc);
lenW = strlen(zWidth);
lenH = strlen(zHeight);
pImage = HtmlAlloc( sizeof(HtmlImage) + lenSrc + lenW + lenH + 3 );
memset(pImage,0,sizeof(HtmlImage));
pImage->htmlPtr = htmlPtr;
pImage->zUrl = (char*)&pImage[1];
strcpy(pImage->zUrl,zSrc);
HtmlFree(zSrc);
pImage->zWidth = &pImage->zUrl[lenSrc+1];
strcpy(pImage->zWidth, zWidth);
pImage->zHeight = &pImage->zWidth[lenW+1];
strcpy(pImage->zHeight, zHeight);
pImage->w = 0;
pImage->h = 0;
if( result==TCL_OK ){
pImage->image = Tk_GetImage(htmlPtr->interp, htmlPtr->clipwin,
zImageName, ImageChangeProc, pImage);
TestPoint(0);
}else{
Tcl_AddErrorInfo(htmlPtr->interp,
"\n (\"-imagecommand\" command executed by html widget)");
Tcl_BackgroundError(htmlPtr->interp);
pImage->image = 0;
TestPoint(0);
}
if( pImage->image==0 ){
HtmlFree((char*)pImage);
TestPoint(0);
return 0;
}
pImage->pNext = htmlPtr->imageList;
htmlPtr->imageList = pImage;
TestPoint(0);
Tcl_ResetResult(htmlPtr->interp);
return pImage;
}
/*
** This routine implements the Sizer() function for <INPUT>,
** <SELECT> and <TEXTAREA> markup.
**
** A side effect of sizing these markups is that widgets are
** created to represent the corresponding input controls.
**
** The function normally returns 0. But if it is dealing with
** a <SELECT> or <TEXTAREA> that is incomplete, 1 is returned.
** In that case, the sizer will be called again at some point in
** the future when more information is available.
*/
int HtmlControlSize(HtmlWidget *htmlPtr, HtmlElement *pElem){
char *zWin; /* Name of child widget that implements this input */
int incomplete = 0; /* True if data is incomplete */
Tcl_DString cmd; /* The complete -formcommand callback */
if( pElem->input.sized ) return 0;
pElem->input.type = InputType(pElem);
switch( pElem->input.type ){
case INPUT_TYPE_Checkbox:
case INPUT_TYPE_Hidden:
case INPUT_TYPE_Image:
case INPUT_TYPE_Radio:
case INPUT_TYPE_Reset:
case INPUT_TYPE_Submit:
case INPUT_TYPE_Text:
case INPUT_TYPE_Password:
case INPUT_TYPE_File: {
int result;
char zToken[50];
if( pElem->input.pForm==0 || htmlPtr->zFormCommand==0
|| htmlPtr->zFormCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
sprintf(zToken," %d input ",pElem->input.pForm->form.id);
Tcl_DStringAppend(&cmd, zToken, -1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
case INPUT_TYPE_Select: {
int result;
char zToken[50];
if( pElem->input.pForm==0 || htmlPtr->zFormCommand==0
|| htmlPtr->zFormCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
sprintf(zToken," %d select ",pElem->input.pForm->form.id);
Tcl_DStringAppend(&cmd, zToken, -1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
AddSelectOptions(&cmd, pElem, pElem->input.pEnd);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
case INPUT_TYPE_TextArea: {
int result;
char zToken[50];
if( pElem->input.pForm==0 || htmlPtr->zFormCommand==0
|| htmlPtr->zFormCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
sprintf(zToken," %d textarea ",pElem->input.pForm->form.id);
Tcl_DStringAppend(&cmd, zToken, -1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
HtmlAppendText(&cmd, pElem, pElem->input.pEnd);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
case INPUT_TYPE_Applet: {
int result;
if( htmlPtr->zAppletCommand==0 || htmlPtr->zAppletCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zAppletCommand, -1);
Tcl_DStringAppend(&cmd, " ", 1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
default: {
CANT_HAPPEN;
pElem->base.flags &= ~HTML_Visible;
pElem->base.style.flags |= STY_Invisible;
pElem->input.tkwin = 0;
break;
}
}
return incomplete;
}
