";
static char* breakString = " or
\n";
static char errbuf[200]; /* A string buffer to temporarily play with error messages */
static char errString[] = "\nErrors encountered while reading document:\n\n";
/* This is the name of the attribute attached to the styles */
static char* styleHTMLCodes = "htmlcodes";
/* ------------------------------------------------------------------------ */
/* Management and utility routines for the magic mappings */
/* ------------------------------------------------------------------------ */
/*
* The next few declarations are for managing the translation file which maps
* special characters to html entities
*/
struct HTMLMagicMapping {
char* magicstring;
int magiclen;
char* string;
};
static struct HTMLMagicMapping HTMLDefaultCharMap[] = {
{ "<", 1, "lt" },
{ ">", 1, "gt" },
{ "&", 1, "amp" },
{ "\"", 1, "quot" },
{ 0, 0 }
};
static struct HTMLMagicMapping* HTMLCharMap = HTMLDefaultCharMap;
static char* HTMLMagicCharacters = 0;
/*
* The InitializeClass() is here to parse the mapping file which translates
* between special characters (e.g. >, <, and &) and the HTML entity which
* represents them (e.g. ">", "<" and "&").
*/
boolean
html__InitializeClass(classID)
struct classheader *classID;
{
struct HTMLMagicMapping* HTMLCharMap = 0;
struct HTMLMagicMapping* hmap;
char* HTMLMagicFile;
int mapcount = 64;
char* hmstr;
FILE* fp;
if (!(HTMLMagicFile = environ_Get("HTMLMAGICFILE"))) {
HTMLMagicFile = environ_AndrewDir("/lib/htmlmagic");
}
fp = fopen(HTMLMagicFile, "r");
if (fp) {
int mc = 0;
char buf[256];
char* mstr;
char* estr;
fgets(buf, sizeof(buf), fp);
if (isdigit(*buf)) {
mapcount = atoi(buf);
HTMLCharMap = (struct HTMLMagicMapping*)malloc(sizeof(struct HTMLMagicMapping)*(mapcount+1));
if (HTMLCharMap) {
hmap = HTMLCharMap;
while (fgets(buf, sizeof(buf), fp)) {
if (buf[0] == '#') {
continue;
}
mstr = strtok(buf, " \t");
if (!mstr) {
continue;
}
estr = strtok(0, " \t\n");
if (estr) {
int ml = strlen(mstr);
hmap->magicstring = (char*)malloc(ml+1);
hmap->string = (char*)malloc(strlen(estr)+1);
if (!(hmap->magicstring && hmap->string)) {
fclose(fp);
return FALSE;
}
strcpy(hmap->magicstring, mstr);
strcpy(hmap->string, estr);
hmap->magiclen=ml;
hmap++,mc++;
if (mc==mapcount) {
/* Stop here. Broken magic file*/
break;
}
}
}
hmap->magicstring = 0;
}
}
fclose(fp);
}
if (HTMLCharMap == 0) {
HTMLCharMap = HTMLDefaultCharMap;
}
/* Build up the string containing all our special characters */
HTMLMagicCharacters = (char*) malloc(sizeof(char)*mapcount);
hmstr = HTMLMagicCharacters;
for (hmap = HTMLCharMap; hmap && hmap->magicstring; hmap++) {
*hmstr++ = *(hmap->magicstring);
}
*hmstr='\0';
return TRUE;
}
/*
* Take a "magic" character and return a string containing the html entity
* which represents that character. len is set to the length of the return
* string.
*/
char*
html_MagicToString(x,len)
char* x;
int* len;
{
struct HTMLMagicMapping* hm;
static char buf[32];
for (hm = HTMLCharMap; hm && hm->magicstring; hm++) {
if (strncmp(hm->magicstring, x, hm->magiclen)==0) {
sprintf(buf, "&%s;", hm->string);
*len = hm->magiclen;
return buf;
}
}
return 0;
}
/*
* Take a string which may be a html entity referring to a character.
* If it is, then the "magic" string which the html translates to is returned.
* else 0 is returned
*/
char*
html_StringToMagic(str)
char* str;
{
struct HTMLMagicMapping* hm;
for (hm = HTMLCharMap; hm && hm->magicstring; hm++) {
if (strcmp(hm->string, str)==0) {
return hm->magicstring;
}
}
return 0;
}
/*
*/
void
html__Inform(self, msg)
struct html* self;
char* msg;
{
struct text* errtext;
static char buf[256];
if (!self->errorBuffer) {
self->errorBuffer = buffer_Create("HTML-Errors", NULL, "text", NULL);
buffer_SetScratch(self->errorBuffer, TRUE);
errtext =(struct text *)buffer_GetData(self->errorBuffer);
text_InsertCharacters(errtext, 0, versionString, strlen(versionString));
text_InsertCharacters(errtext, text_GetLength(errtext), errString, strlen(errString));
}
sprintf(buf, "line %ld: %s\n", self->lineNumber, msg);
if (self->errorBuffer) {
errtext =(struct text *)buffer_GetData(self->errorBuffer);
text_InsertCharacters(errtext, text_GetLength(errtext), buf, strlen(buf));
} else {
fprintf(stderr, buf);
}
}
boolean
html__HasErrors(self)
struct html* self;
{
if (self->errorBuffer) {
return TRUE;
} else {
return FALSE;
}
}
/* ------------------------------------------------------------------------ */
/* Management of instances of entities: Each instance of an entity may have */
/* variables attached to it */
/* ------------------------------------------------------------------------ */
/* Attach a variable assignment to a style */
/* If the value is NULL, then empty string ("") is placed as value */
static void
storeVar(style, key, value)
struct style* style;
char* key;
char* value;
{
struct keylist* k = keyList;
char* s;
for (s = key; s && *s; s++) {
if (isupper(*s)) {
*s = tolower(*s);
}
}
for (k = keyList; k && (strcmp(k->name, key)!=0) ; k = k->next)
;
if (!k) {
/* Record the key for later use... */
struct keylist* nk = (struct keylist*) malloc(sizeof(struct keylist));
if (nk) {
strcpy(nk->name, key);
nk->next = keyList;
keyList = nk;
}
}
style_AddAttribute(style, key, value ? value : "");
}
/* Parse a variable list from a tag calling storeVar on all the variables */
static void
addVars(style, vars)
struct style* style;
char* vars;
{
char* s = vars;
char* value = 0;
char* key = s;
int inquote = 0;
for ( ; s && *s; s++) {
if (*s == '\"') {
inquote = !inquote;
} else if (*s == '=' && !inquote) {
*s = '\0';
value = s+1;
} else if (strchr(whiteSpace, *s)) {
if (!inquote) {
/* We have the end of a variable. Store it */
*s = '\0';
storeVar(style, key, value);
value = 0;
key = s+1;
} /* else ignore it */
}
}
if (*key != '\0') {
storeVar(style, key, value);
}
}
char*
html_StyleToVariables(style)
struct style* style;
{
/* XXX: We don't watch to see if buf is overrun! */
struct keylist* k;
char* s;
static char buf[256];
char* bufptr = buf;
buf[0] = '\0';
for (k = keyList; k; k = k->next) {
s = style_GetAttribute(style, k->name);
if (s) {
*bufptr++ = ' ';
/* We have a valid variable attached to this style. Dump it */
if (s && *s != '\0') {
sprintf(bufptr, "%s=%s", k->name, s);
} else {
strcpy(bufptr, k->name);
}
bufptr += strlen(bufptr);
}
}
return buf;
}
/* ------------------------------------------------------------------------ */
/* Some routines for outside use. I.e. the view object */
/* ------------------------------------------------------------------------ */
void
html__ChangeTitle(self, name)
struct html* self;
char* name;
{
struct buffer* buf = buffer_FindBufferByData(self);
if (self->title) {
free(self->title);
}
self->title = (char*) malloc(strlen(name)+1);
if (self->title) {
strcpy(self->title, name);
if (buf) {
buffer_SetName(buf, self->title);
}
html_SetModified(self);
html_NotifyObservers(self, observable_OBJECTCHANGED);
} else if (buf) {
buffer_SetName(buf, "Untitled");
}
}
void
html__ChangeIndexable(self, flag)
struct html* self;
int flag;
{
self->isindex = flag;
html_SetModified(self);
html_NotifyObservers(self, observable_OBJECTCHANGED);
}
void
html__AddLink(self, inpos, len, uri)
struct html* self;
long inpos;
long len;
char* uri;
{
int pos = inpos;
char vars[256];
struct entityMapping* em;
struct entityElement* ep;
em = getEntityMapping("a"); /* Get the stuff about this */
sprintf(vars, "href=%s", uri);
ep = pushEntity(self, &pos, em, "a", vars, 1);
pos += len;
closeEntity(self, ep, &pos, 1);
popEntity(self);
html_RegionModified(self, inpos, len);
html_NotifyObservers(self, observable_OBJECTCHANGED);
}
char*
html__GetAnchorDest(self, pos)
struct html* self;
long pos;
{
struct environment* env;
env = environment_GetInnerMost(self->header.text.rootEnvironment, pos);
while (env && !(env->type == environment_Style && strcmp(env->data.style->name, "anchor") == 0)) {
env = (struct environment*)environment_GetParent(env);
}
if (!env) {
return 0;
}
return html_StyleToVariables(env->data.style);
}
char*
html__GetAttribute(self, env, attr)
struct html* self;
struct environment* env;
char* attr;
{
if (env->type != environment_Style) {
return 0;
} else {
return style_GetAttribute(env->data.style, attr);
}
}
void
html__ChangeAttribute(self, tv, env, attr, value)
struct html* self;
struct view* tv;
struct environment* env;
char* attr;
char* value;
{
char cb[256];
char* ptr;
cb[0] = '0';
/* XXX: BUG! NYI
* We need to take a copy of the style and free the old one, otherwise
* we'll be adding this attribute onto all styles...
*/
if (env->type == environment_Style) {
if (value && (*value=='\0' || strcmp(value, "\"\"")) == 0) {
style_RemoveAttribute(env->data.style, attr);
} else {
storeVar(env->data.style, attr, value);
}
/* Check to see if this modification should trigger any callback */
strcpy(cb, "callback:");
strcat(cb, attr);
if (ptr = style_GetAttribute(env->data.style, cb)) {
/* Now we use the proctable to call the callback */
/* This code is taken from the metax class */
struct proctable_Entry *proc;
struct im *im = view_GetIM(tv);
printf("doing a callback: %s\n", ptr);
proc = proctable_Lookup(ptr);
if(proc) {
switch(keystate_DoProc(im->keystate, proc, 0, tv)) {
case keystate_NoProc:
message_DisplayString(im, 0, "Could not load procedure");
break;
case keystate_TypeMismatch:
message_DisplayString(im, 0, "Bad command");
break;
}
} else {
message_DisplayString(im, 0, "Do nothing");
}
}
/* We're done */
html_SetModified(self);
html_NotifyObservers(self, observable_OBJECTCHANGED);
}
}
void
html__GetAttributeList(self, env, list, count)
struct html* self;
struct environment* env;
char* list[];
int* count;
{
struct keylist* k;
char* s;
*count = 0;
if (env->type != environment_Style) {
return;
}
for (k = keyList; k; k = k->next) {
s = style_GetAttribute(env->data.style, k->name);
if (s) {
/* We have a valid variable attached to this style. Dump it */
list[*count] = (char*)malloc(strlen(k->name)+1);
strcpy(list[*count], k->name);
(*count)++;
}
}
}
/* ------------------------------------------------------------------------ */
/* Internal callbacks do not need to mess with modified flags or anything
* like that: they are purely used during parsing. However, at the end of
* a parse run, you should make sure you call the SetModified and
* NotifyObservers methods. */
/* ------------------------------------------------------------------------ */
static void
ChangeTitle(self, ep, buf, len) /* Internal Callback */
struct html* self;
struct entityElement* ep;
char* buf;
long len;
{
if (self->title) {
free(self->title);
}
self->title = (char*) malloc(len+1);
strncpy(self->title, buf, len);
self->title[len]='\0';
}
static void
ChangeIndexable(self, ep, buf, len) /* Internal Callback */
struct html* self;
struct entityElement* ep;
char* buf;
long len;
{
self->isindex = 1;
}
/* ------------------------------------------------------------------------ */
/* Play around with entity environments */
/* ------------------------------------------------------------------------ */
/* getEntityCode: take a string, do a lookup and return the code */
static struct entityMapping*
getEntityMapping(string)
char* string;
{
struct entityMapping* b;
for (b = basicEntities; b->string; b++) {
if (strcmp(b->string, string) == 0) {
return b;
}
}
return &noEntity;
}
/* Take an entity off the stack */
static void
popEntity(self)
struct html* self;
{
struct entityElement* e = self->entities;
if (e) {
self->entities = e->prev;
/* We don't destroy the sub objects, as these are now hooked into the text object... */
free(e);
}
}
/* Push an entity onto the stack. This should be called when parsing
* It records the current position and prepares a style to plop down
* when the end of the entity is known
*/
static struct entityElement*
pushEntity(self, pos, em, name, vars, force)
struct html* self;
long* pos;
struct entityMapping* em;
char* name;
char* vars;
int force;
{
char* string;
char buf[256];
struct entityElement* e;
struct environment *env;
e = (struct entityElement*) malloc(sizeof(struct entityElement));
if (e) {
/* adjust the list with the new entity, default values */
e->prev = self->entities;
e->em = em;
if (pos) {
e->start = *pos;
} else {
e->start = 0;
}
e->style = 0;
e->data = 0;
strcpy(e->string, name);
if (force >= 0) {
if (!withinEntity(self, entityHead) || force) {
struct style* thisStyle;
/* We find the stylename no matter what, as it's useful */
struct styleMapping* sm = stylemap;
for (; sm && sm->styleName && strcmp(sm->entityName, name)!=0; sm++) {
/* empty loop */;
}
if (sm->styleName) {
string = sm->styleName;
} else {
string = name;
}
if (!(em->flags & entFlagsNoStyle)) {
thisStyle = stylesheet_Find(html_GetStyleSheet(self), string);
/* Get the thisStyle for this entity, make one up if it's bogus */
if (!thisStyle) {
sprintf(errbuf, "could not load the style \"%s\". An error in the html template?", name);
html_Inform(self, errbuf);
/* If things go wrong, who you gunna call? */
thisStyle = style_New();
style_SetName(thisStyle, name);
style_AddAttribute(thisStyle, "color", "blue");
}
/* Create a new thisStyle, which is copy of the norm as handle for these specific attributes */
e->style = style_New();
style_Copy(thisStyle, e->style);
/* We store all sorts of useful stuff attached to the style */
sprintf(buf, "%d", (em->flags | (int)em->code));
style_AddAttribute(e->style, styleHTMLCodes, buf);
if (vars && *vars) {
addVars(e->style, vars);
}
}
if (em->code == entityRule) {
hrule(self, pos);
} else if (em->code == entityImage) {
html_AddImage(self, pos, style_GetAttribute(e->style, "src"));
self->withinPar = 1;
(*pos)++;
} else if (em->flags & entFlagsUnknown) {
/* Unknown entities: dump out the name of the entity, with spaces around it */
/* The spaces ensure that we get the style wrapping in the right order, by */
/* Frigging the start pos of this entity */
int len;
/* XXX: Should read the ALT variable and use that text if available */
sprintf(buf, " <%s> ", name);
len = strlen(buf);
html_AlwaysInsertCharacters(self, *pos, buf, len);
if (self->tagStyle) {
env = html_AlwaysAddStyle(self, *pos+1, len-2, self->tagStyle);
if (env) environment_SetStyle(env, FALSE, FALSE);
}
self->withinPar = 1;
*pos += len;
}
}
}
} else {
html_Inform(self, "there's no memory left to parse this document.");
}
self->entities = e;
return e;
}
static struct entityElement*
entityPeek(self)
struct html* self;
{
return self->entities;
}
/* Run down the stack, returns TRUE if we can find the entityCode anywhere */
static struct entityElement*
withinEntity(self, code)
struct html* self;
enum entityCode code;
{
struct entityElement* e;
for (e = self->entities; e; e=e->prev) {
if (e->em->code == code) {
return e;
}
}
return 0;
}
/* Run down the stack, returns entity if we can find the entityCode anywhere */
static struct entityElement*
withinEntityClass(self, code)
struct html* self;
enum entityCode code;
{
struct entityElement* e;
for (e = self->entities; e; e=e->prev) {
if ((int)e->em->code & (int)code) {
return e;
}
}
return 0;
}
/*
Find first entity in buffer. Return strlower(entity name) (vars) (pos) and
delete the entity from the input buffer.
Return value:
If the return value signifies a token, then varPos is
set to the character position at which the token should take effect.
Note: The following routine is destructive to buf.
*/
int
html_FindEntity(buf, pos, entity, vars)
char* buf;
long* pos;
char* entity;
char* vars;
{
char* s;
/* .....
is detected, OR
* if an implied one (e.g. from a title, or somesuch) is detected.
*/
int parImplied = 0; /* IF parbreak implied from previous style */
int brImplied = 0; /* IF a line break has been implied by the last style */
int newlines = 0;
long end;
long i;
long elen;
int levels;
char c;
long envpos;
char outbuf[180],*outp,*endp,*temp;
char *buf = NULL;
long bufLen;
/* Quicky optimisation */
if (len <= 0 ) return;
self->lineNumber = 0; /* In case any errors are produced during a write. Can it happen? */
/* fprintf(stderr, "WriteSubString(%ld, %ld)\n", pos, len); */
/* Make sure we start in the right state... */
/* This should be set by looking at curenv(pos) */
self->adornment = 0;
endp = outbuf + 78; /* Hackety hack */
outp = outbuf;
startenv = environment_GetInnerMost(self->header.text.rootEnvironment, pos);
endenv = environment_GetInnerMost(self->header.text.rootEnvironment, pos + len - 1);
rootenv = environment_GetCommonParent(startenv, endenv);
/* Determine the root of the environment, by going back up the tree */
for (envpos = environment_Eval(rootenv);
pos == envpos && pos + len == envpos + rootenv->header.nestedmark.length;
rootenv = (struct environment *) rootenv->header.nestedmark.parent,
envpos = environment_Eval(rootenv));
/* Now open all starting environments up */
curenv = rootenv;
while (curenv != startenv) {
curenv = environment_GetChild(curenv, pos);
/* Make sure we write out buffer if it gets too full */
if ((curenv->type == environment_Style &&
(outp + 2 + strlen(curenv->data.style->name) > endp))
|| (curenv->type == environment_View && outp != outbuf)){
PutsRange(self, outbuf, file, outp);
outp = outbuf;
}
/* The actual open environment */
if (curenv->type == environment_Style){
outp = html_EnvStart(self, outp, curenv->data.style, &parImplied, &brImplied, &newlines);
}
}
/* Now, we go through the document looking at each environment */
i = pos;
end = pos + len;
while (i < end) {
newenv = environment_GetInnerMost(self->header.text.rootEnvironment, i);
elen = environment_GetNextChange(self->header.text.rootEnvironment, i);
if (elen + i > end)
elen = end - i;
if (curenv != newenv) {
/* A new environment, so make sure previous ones are closed */
parentenv = environment_GetCommonParent(curenv, newenv);
levels = environment_Distance(curenv, parentenv);
while (levels > 0) {
if (curenv->type == environment_Style) {
outp = html_EnvEnd(self, outp, curenv->data.style, &parImplied, &brImplied);
}
curenv = (struct environment*)environment_GetParent(curenv);
levels--;
}
curenv = parentenv;
/* Now we're in a new environment, curenv is the parent? */
if (curenv != newenv) {
struct environment *stack[100];
struct environment *te;
int level = 0;
/* Open all of the environments that start at this spot */
for (te = newenv; te != parentenv; te = (struct environment *) te->header.nestedmark.parent)
stack[level++] = te;
while (level > 0) {
curenv = stack[--level];
if ((curenv->type == environment_Style &&
(outp + 2 + strlen(curenv->data.style->name) > endp))
|| (curenv->type == environment_View && outp != outbuf)){
PutsRange(self, outbuf, file, outp);
outp = outbuf;
}
if (curenv->type == environment_Style){
outp = html_EnvStart(self, outp, curenv->data.style, &parImplied, &brImplied, &newlines);
}
}
}
}
if (curenv->type == environment_View) {
/* Views (inner sub-objects) are ignored */
if(outp != outbuf){
/* flush out remaining cached characters */
PutsRange(self, outbuf, file, outp);
outp = outbuf;
}
i += curenv->header.nestedmark.length;
elen = 0;
}
elen += i;
bufLen = 0;
if (self->adornment) {
i = elen; /* Jump to end of text */
}
while (i < elen) {
/* Code for writing out actual text */
if (bufLen == 0) {
buf = html_GetBuf(self, i, 1024, &bufLen);
}
bufLen--, c = *buf++;
if (strchr(HTMLMagicCharacters, c)) {
char* s;
int len;
s = html_MagicToString(buf-1,&len);
while (s && *s) {
*outp++ = *s++;
}
buf+=len-1;
lastblankset = FALSE;
} else {
switch(c) {
case '\n':
/* Make sure pre-formatted doesn't get munched. */
if (withinEntity(self, entityPre)) {
*outp++ = c;
} else {
newlines++;
}
break;
default:
/* This is a normal character */
/* However, multiple spaces get shrunk... unless PRE */
if (withinEntity(self, entityPre)) {
*outp++ = c;
} else {
outp = outputNewlines(newlines, parImplied, brImplied, outp);
newlines = 0;
parImplied = 0;
brImplied = 0;
if(c == ' ' || c == '\t' || c == '\n'){
if(lastblankset == FALSE){
*outp++ = ' ';
lastblankset = TRUE;
}
} else {
*outp++ = c;
lastblankset = FALSE;
}
}
}
}
/* Buffer management */
if (outp > endp) {
PutsRange(self, outbuf, file, outp);
outp = outbuf;
}
i++;
}
}
/* flush out cached characters */
if(outp != outbuf){
PutsRange(self, outbuf,file,outp);
}
/* And close all remaining environments */
levels = environment_Distance(curenv, rootenv);
while (levels-- > 0) {
if (curenv->type == environment_Style) {
outp = html_EnvEnd(self, outbuf, curenv->data.style, &parImplied, &brImplied);
}
curenv = (struct environment*)environment_GetParent(curenv);
PutsRange(self, outbuf, file, outp);
}
}
/* Make the (pos,len) region a list item, with a tagged bit inserted at the start */
boolean
html__TagItem(self, pos, len, text, itemS, extraStyle)
struct html* self;
long pos, len;
char* text;
char* itemS;
struct style* extraStyle;
{
struct environment *env;
int tlen = strlen(text);
struct style* iStyle = self->itemStyle;
if (itemS) {
iStyle = stylesheet_Find(html_GetStyleSheet(self),itemS);
}
if (!(self->tagStyle && self->itemStyle)) {
return FALSE;
}
html_AlwaysInsertCharacters(self, pos, text, tlen);
if (extraStyle) {
env = html_AlwaysAddStyle(self, pos, tlen, extraStyle);
if (env) {
environment_SetStyle(env, FALSE, FALSE);
}
}
env = html_AlwaysAddStyle(self, pos, tlen, self->tagStyle);
if (env) {
environment_SetStyle(env, FALSE, FALSE);
}
env = html_AlwaysAddStyle(self, pos, len+tlen, iStyle);
if (env) {
environment_SetStyle(env, FALSE, FALSE);
}
html_RegionModified(self, pos, len+tlen);
html_NotifyObservers(self, observable_OBJECTCHANGED);
return TRUE;
}
int
html_StyleToCodes(style)
struct style* style;
{
char* s = style_GetAttribute(style, styleHTMLCodes);
if (!s) {
return 0;
}
return atoi(s);
}
/* Look at pos and untag the paragraph, getting rid of tag and styles */
int
html__UntagItem(self, pos)
struct html* self;
long pos;
{
struct environment* env;
struct environment* item;
struct environment* list;
struct environment* enext;
int itempos, itemlen;
int code;
long len;
/* Find the tag */
enext = environment_GetInnerMost(self->header.text.rootEnvironment, pos);
do {
env = enext;
while (env && env->type != environment_Style){
env = (struct environment*)environment_GetParent(env);
}
if (!env) {
return 0;
}
code = html_StyleToCodes(env->data.style);
if (code & (int)entityList) {
/* We couldn't find the item before we left the list */
return 0;
}
enext = (struct environment*)environment_GetParent(env);
} while (!(code & entFlagsAdornment));
/* Find the item */
do {
item = enext;
while (item && item->type != environment_Style){
item = (struct environment*)environment_GetParent(item);
}
if (!item) {
return 0;
}
code = html_StyleToCodes(item->data.style);
if (code & (int)entityList) {
/* We couldn't find the item before we left the list */
return 0;
}
enext = (struct environment*)environment_GetParent(item);
} while ((code & 0xff) != (int)entityListItem);
/* Find the list */
do {
list = enext;
while (list && list->type != environment_Style){
list = (struct environment*)environment_GetParent(list);
}
if (!list) {
return 0;
}
code = html_StyleToCodes(list->data.style);
enext = (struct environment*)environment_GetParent(list);
} while (!(code & (int)entityList));
/* Delete the list-item style */
itempos = environment_Eval(item);
itemlen = environment_GetLength(item);
environment_Delete(item);
/* delete the tag. This will automatically remove the adorning style */
len = environment_GetLength(env);
html_AlwaysDeleteCharacters(self, environment_Eval(env), len);
/* Delete the list style */
environment_Remove(self->header.text.rootEnvironment, itempos, itemlen-len+1, environment_Style, FALSE);
/* Tell people about it */
html_RegionModified(self, itempos, itemlen);
html_NotifyObservers(self, observable_OBJECTCHANGED);
return len;
}
struct environment*
html__GetEntityEnvironment(self, pos, env)
struct html* self;
long pos;
struct environment* env;
{
struct environment* e, *parent;
char* s;
if (env) {
e = env;
} else {
e = environment_GetInnerMost(self->header.text.rootEnvironment, pos);
}
while(e) {
/* Check if this is the one. */
if (e->type == environment_Style && (s = html_GetAttribute(self, e, "htmladornment")) == 0) {
break;
}
parent = (struct environment*)environment_GetParent(e);
e = parent;
};
return e;
}
/*
* Find a file by looking either at the relative file passed in as
* second parameter, or by looking along a list of pseudo-roots
*/
static char*
findLocalFile(path, relativeRoot)
char* path;
char* relativeRoot;
{
static char buf[256];
char* s;
char* ptr = buf;
if (*path == '/') {
ptr = environ_GetProfile("webPath");
while (ptr) {
s = strchr(ptr, ',');
if (s) {
strncpy(buf, ptr, s-ptr);
buf[s-ptr] = '\0';
ptr = s+1;
} else {
strcpy(buf, ptr);
ptr = 0;
}
strcat(buf, path);
/* Check buf */
if (access(buf, R_OK) == 0) {
return buf;
}
}
return 0;
} else {
/* Relative pathname, use current buffer */
strcpy(buf, relativeRoot);
if (s = strrchr(buf, '/')) {
s[1] = '\0';
} else {
/* Bizarreness happening! */
return 0;
}
strcat(buf, path);
if (access(buf, R_OK) == 0) {
return buf;
}
return 0;
}
}