Annotation of libwww/Library/src/HTAnchor.c, revision 1.1.1.1
1.1 timbl 1: /* Hypertext "Anchor" Object HTAnchor.c
2: ** ==========================
3: **
4: ** An anchor represents a region of a hypertext document which is linked to
5: ** another anchor in the same or a different document.
6: **
7: ** History
8: **
9: ** Nov 1990 Written in Objective-C for the NeXT browser (TBL)
10: ** 24-Oct-1991 (JFG), written in C, browser-independant
11: ** 21-Nov-1991 (JFG), first complete version
12: **
13: ** (c) Copyright CERN 1991 - See Copyright.html
14: */
15:
16: #define HASH_SIZE 101 /* Arbitrary prime. Memory/speed tradeoff */
17:
18: #include <ctype.h>
19: #include "tcp.h"
20: #include "HTAnchor.h"
21: #include "HTUtils.h"
22: #include "HTParse.h"
23:
24: typedef struct _HyperDoc Hyperdoc;
25: #ifdef vms
26: struct _HyperDoc {
27: int junk; /* VMS cannot handle pointers to undefined structs */
28: };
29: #endif
30:
31: PRIVATE HTList **adult_table=0; /* Point to table of lists of all parents */
32:
33: /* Creation Methods
34: ** ================
35: **
36: ** Do not use "new" by itself outside this module. In order to enforce
37: ** consistency, we insist that you furnish more information about the
38: ** anchor you are creating : use newWithParent or newWithAddress.
39: */
40:
41: PRIVATE HTParentAnchor * HTParentAnchor_new
42: NOARGS
43: {
44: HTParentAnchor *newAnchor =
45: (HTParentAnchor *) calloc (1, sizeof (HTParentAnchor)); /* zero-filled */
46: newAnchor->parent = newAnchor;
47: return newAnchor;
48: }
49:
50: PRIVATE HTChildAnchor * HTChildAnchor_new
51: NOARGS
52: {
53: return (HTChildAnchor *) calloc (1, sizeof (HTChildAnchor)); /* zero-filled */
54: }
55:
56:
57: /* Case insensitive string comparison
58: ** ----------------------------------
59: ** On entry,
60: ** s Points to one string, null terminated
61: ** t points to the other.
62: ** On exit,
63: ** returns YES if the strings are equivalent ignoring case
64: ** NO if they differ in more than their case.
65: */
66:
67: PRIVATE BOOL equivalent
68: ARGS2 (CONST char *,s, CONST char *,t)
69: {
70: if (s && t) { /* Make sure they point to something */
71: for ( ; *s && *t ; s++, t++) {
72: if (TOUPPER(*s) != TOUPPER(*t))
73: return NO;
74: }
75: return TOUPPER(*s) == TOUPPER(*t);
76: } else
77: return s == t; /* Two NULLs are equivalent, aren't they ? */
78: }
79:
80:
81: /* Create new or find old sub-anchor
82: ** ---------------------------------
83: **
84: ** This one is for a new anchor being edited into an existing
85: ** document. The parent anchor must already exist.
86: */
87:
88: PRIVATE HTChildAnchor * HTAnchor_findChild
89: ARGS2 (HTParentAnchor *,parent, CONST char *,tag)
90: {
91: HTChildAnchor *child;
92: HTList *kids;
93:
94: if (! parent) {
95: if (TRACE) printf ("HTAnchor_findChild called with NULL parent.\n");
96: return NULL;
97: }
98: if (kids = parent->children) { /* parent has children : search them */
99: if (tag && *tag) { /* TBL */
100: while (child = HTList_nextObject (kids)) {
101: if (equivalent(child->tag, tag)) { /* Case sensitive 920226 */
102: if (TRACE) printf (
103: "Child anchor %p of parent %p with name `%s' already exists.\n",
104: child, parent, tag);
105: return child;
106: }
107: }
108: } /* end if tag is void */
109: } else /* parent doesn't have any children yet : create family */
110: parent->children = HTList_new ();
111:
112: child = HTChildAnchor_new ();
113: if (TRACE) fprintf(stderr, "new Anchor %p named `%s' is child of %p\n",
114: child, (int)tag ? tag : (CONST char *)"" , parent); /* int for apollo */
115: HTList_addObject (parent->children, child);
116: child->parent = parent;
117: StrAllocCopy(child->tag, tag);
118: return child;
119: }
120:
121:
122: /* Create or find a child anchor with a possible link
123: ** --------------------------------------------------
124: **
125: ** Create new anchor with a given parent and possibly
126: ** a name, and possibly a link to a _relatively_ named anchor.
127: ** (Code originally in ParseHTML.h)
128: */
129: PUBLIC HTChildAnchor * HTAnchor_findChildAndLink
130: ARGS4(
131: HTParentAnchor *,parent, /* May not be 0 */
132: CONST char *,tag, /* May be "" or 0 */
133: CONST char *,href, /* May be "" or 0 */
134: HTLinkType *,ltype /* May be 0 */
135: )
136: {
137: HTChildAnchor * child = HTAnchor_findChild(parent, tag);
138: if (href && *href) {
139: char * parsed_address;
140: HTAnchor * dest;
141: parsed_address = HTParse(href, HTAnchor_address((HTAnchor *) parent),
142: PARSE_ALL);
143: dest = HTAnchor_findAddress(parsed_address);
144: HTAnchor_link((HTAnchor *) child, dest, ltype);
145: free(parsed_address);
146: }
147: return child;
148: }
149:
150:
151: /* Create new or find old named anchor
152: ** -----------------------------------
153: **
154: ** This one is for a reference which is found in a document, and might
155: ** not be already loaded.
156: ** Note: You are not guaranteed a new anchor -- you might get an old one,
157: ** like with fonts.
158: */
159:
160: HTAnchor * HTAnchor_findAddress
161: ARGS1 (CONST char *,address)
162: {
163: char *tag = HTParse (address, "", PARSE_ANCHOR); /* Anchor tag specified ? */
164:
165: /* If the address represents a sub-anchor, we recursively load its parent,
166: then we create a child anchor within that document. */
167: if (*tag) {
168: char *docAddress = HTParse(address, "", PARSE_ACCESS | PARSE_HOST |
169: PARSE_PATH | PARSE_PUNCTUATION);
170: HTParentAnchor * foundParent =
171: (HTParentAnchor *) HTAnchor_findAddress (docAddress);
172: HTChildAnchor * foundAnchor = HTAnchor_findChild (foundParent, tag);
173: free (docAddress);
174: free (tag);
175: return (HTAnchor *) foundAnchor;
176: }
177:
178: else { /* If the address has no anchor tag, check whether we have this node */
179: int hash;
180: CONST char *p;
181: HTList * adults;
182: HTList *grownups;
183: HTParentAnchor * foundAnchor;
184:
185: free (tag);
186:
187: /* Select list from hash table */
188: for(p=address, hash=0; *p; p++) hash = (hash * 3 + *p) % HASH_SIZE;
189: if (!adult_table)
190: adult_table = (HTList**) calloc(HASH_SIZE, sizeof(HTList*));
191: if (!adult_table[hash]) adult_table[hash] = HTList_new();
192: adults = adult_table[hash];
193:
194: /* Search list for anchor */
195: grownups = adults;
196: while (foundAnchor = HTList_nextObject (grownups)) {
197: if (equivalent(foundAnchor->address, address)) {
198: if (TRACE) fprintf(stderr, "Anchor %p with address `%s' already exists.\n",
199: foundAnchor, address);
200: return (HTAnchor *) foundAnchor;
201: }
202: }
203:
204: /* Node not found : create new anchor */
205: foundAnchor = HTParentAnchor_new ();
206: if (TRACE) fprintf(stderr, "New anchor %p has hash %d and address `%s'\n",
207: foundAnchor, hash, address);
208: StrAllocCopy(foundAnchor->address, address);
209: HTList_addObject (adults, foundAnchor);
210: return (HTAnchor *) foundAnchor;
211: }
212: }
213:
214:
215: /* Delete an anchor and possibly related things (auto garbage collection)
216: ** --------------------------------------------
217: **
218: ** The anchor is only deleted if the corresponding document is not loaded.
219: ** All outgoing links from parent and children are deleted, and this anchor
220: ** is removed from the sources list of all its targets.
221: ** We also try to delete the targets whose documents are not loaded.
222: ** If this anchor's source list is empty, we delete it and its children.
223: */
224:
225: PRIVATE void deleteLinks
226: ARGS1 (HTAnchor *,this)
227: {
228: if (! this)
229: return;
230:
231: /* Recursively try to delete target anchors */
232: if (this->mainLink.dest) {
233: HTParentAnchor *parent = this->mainLink.dest->parent;
234: HTList_removeObject (parent->sources, this);
235: if (! parent->document) /* Test here to avoid calling overhead */
236: HTAnchor_delete (parent);
237: }
238: if (this->links) { /* Extra destinations */
239: HTLink *target;
240: while (target = HTList_removeLastObject (this->links)) {
241: HTParentAnchor *parent = target->dest->parent;
242: HTList_removeObject (parent->sources, this);
243: if (! parent->document) /* Test here to avoid calling overhead */
244: HTAnchor_delete (parent);
245: }
246: }
247: }
248:
249: PUBLIC BOOL HTAnchor_delete
250: ARGS1 (HTParentAnchor *,this)
251: {
252: HTChildAnchor *child;
253:
254: /* Don't delete if document is loaded */
255: if (this->document)
256: return NO;
257:
258: /* Recursively try to delete target anchors */
259: deleteLinks ((HTAnchor *) this);
260:
261: if (! HTList_isEmpty (this->sources)) { /* There are still incoming links */
262: /* Delete all outgoing links from children, if any */
263: HTList *kids = this->children;
264: while (child = HTList_nextObject (kids))
265: deleteLinks ((HTAnchor *) child);
266: return NO; /* Parent not deleted */
267: }
268:
269: /* No more incoming links : kill everything */
270: /* First, recursively delete children */
271: while (child = HTList_removeLastObject (this->children)) {
272: deleteLinks ((HTAnchor *) child);
273: free (child->tag);
274: free (child);
275: }
276:
277: /* Now kill myself */
278: HTList_delete (this->children);
279: HTList_delete (this->sources);
280: free (this->address);
281: /* Devise a way to clean out the HTFormat if no longer needed (ref count?) */
282: free (this);
283: return YES; /* Parent deleted */
284: }
285:
286:
287: /* Move an anchor to the head of the list of its siblings
288: ** ------------------------------------------------------
289: **
290: ** This is to ensure that an anchor which might have already existed
291: ** is put in the correct order as we load the document.
292: */
293:
294: void HTAnchor_makeLastChild
295: ARGS1(HTChildAnchor *,this)
296: {
297: if (this->parent != (HTParentAnchor *) this) { /* Make sure it's a child */
298: HTList * siblings = this->parent->children;
299: HTList_removeObject (siblings, this);
300: HTList_addObject (siblings, this);
301: }
302: }
303:
304: /* Data access functions
305: ** ---------------------
306: */
307:
308: PUBLIC HTParentAnchor * HTAnchor_parent
309: ARGS1 (HTAnchor *,this)
310: {
311: return this ? this->parent : NULL;
312: }
313:
314: void HTAnchor_setDocument
315: ARGS2 (HTParentAnchor *,this, HyperDoc *,doc)
316: {
317: if (this)
318: this->document = doc;
319: }
320:
321: HyperDoc * HTAnchor_document
322: ARGS1 (HTParentAnchor *,this)
323: {
324: return this ? this->document : NULL;
325: }
326:
327:
328: /* We don't want code to change an address after anchor creation... yet ?
329: void HTAnchor_setAddress
330: ARGS2 (HTAnchor *,this, char *,addr)
331: {
332: if (this)
333: StrAllocCopy (this->parent->address, addr);
334: }
335: */
336:
337: char * HTAnchor_address
338: ARGS1 (HTAnchor *,this)
339: {
340: char *addr = NULL;
341: if (this) {
342: if (((HTParentAnchor *) this == this->parent) ||
343: !((HTChildAnchor *) this)->tag) { /* it's an adult or no tag */
344: StrAllocCopy (addr, this->parent->address);
345: }
346: else { /* it's a named child */
347: addr = malloc (2 + strlen (this->parent->address)
348: + strlen (((HTChildAnchor *) this)->tag));
349: if (addr == NULL) outofmem(__FILE__, "HTAnchor_address");
350: sprintf (addr, "%s#%s", this->parent->address,
351: ((HTChildAnchor *) this)->tag);
352: }
353: }
354: return addr;
355: }
356:
357:
358:
359: void HTAnchor_setFormat
360: ARGS2 (HTParentAnchor *,this, HTFormat *,form)
361: {
362: if (this)
363: this->format = form;
364: }
365:
366: HTFormat * HTAnchor_format
367: ARGS1 (HTParentAnchor *,this)
368: {
369: return this ? this->format : NULL;
370: }
371:
372:
373:
374: void HTAnchor_setIndex
375: ARGS1 (HTParentAnchor *,this)
376: {
377: if (this)
378: this->isIndex = YES;
379: }
380:
381: BOOL HTAnchor_isIndex
382: ARGS1 (HTParentAnchor *,this)
383: {
384: return this ? this->isIndex : NO;
385: }
386:
387:
388:
389: BOOL HTAnchor_hasChildren
390: ARGS1 (HTParentAnchor *,this)
391: {
392: return this ? ! HTList_isEmpty(this->children) : NO;
393: }
394:
395: /* Title handling
396: */
397: CONST char * HTAnchor_title
398: ARGS1 (HTParentAnchor *,this)
399: {
400: return this ? this->title : 0;
401: }
402:
403: void HTAnchor_setTitle
404: ARGS2(HTParentAnchor *,this, CONST char *,title)
405: {
406: StrAllocCopy(this->title, title);
407: }
408:
409: void HTAnchor_appendTitle
410: ARGS2(HTParentAnchor *,this, CONST char *,title)
411: {
412: StrAllocCat(this->title, title);
413: }
414:
415: /* Link this Anchor to another given one
416: ** -------------------------------------
417: */
418:
419: BOOL HTAnchor_link
420: ARGS3(HTAnchor *,source, HTAnchor *,destination, HTLinkType *,type)
421: {
422: if (! (source && destination))
423: return NO; /* Can't link to/from non-existing anchor */
424: if (TRACE) printf ("Linking anchor %p to anchor %p\n", source, destination);
425: if (! source->mainLink.dest) {
426: source->mainLink.dest = destination;
427: source->mainLink.type = type;
428: } else {
429: HTLink * newLink = (HTLink *) malloc (sizeof (HTLink));
430: if (newLink == NULL) outofmem(__FILE__, "HTAnchor_link");
431: newLink->dest = destination;
432: newLink->type = type;
433: if (! source->links)
434: source->links = HTList_new ();
435: HTList_addObject (source->links, newLink);
436: }
437: if (!destination->parent->sources)
438: destination->parent->sources = HTList_new ();
439: HTList_addObject (destination->parent->sources, source);
440: return YES; /* Success */
441: }
442:
443:
444: /* Manipulation of links
445: ** ---------------------
446: */
447:
448: HTAnchor * HTAnchor_followMainLink
449: ARGS1 (HTAnchor *,this)
450: {
451: return this->mainLink.dest;
452: }
453:
454: HTAnchor * HTAnchor_followTypedLink
455: ARGS2 (HTAnchor *,this, HTLinkType *,type)
456: {
457: if (this->mainLink.type == type)
458: return this->mainLink.dest;
459: if (this->links) {
460: HTList *links = this->links;
461: HTLink *link;
462: while (link = HTList_nextObject (links))
463: if (link->type == type)
464: return link->dest;
465: }
466: return NULL; /* No link of this type */
467: }
468:
469: BOOL HTAnchor_makeMainLink
470: ARGS2 (HTAnchor *,this, HTLink *,movingLink)
471: {
472: /* Check that everything's OK */
473: if (! (this && HTList_removeObject (this->links, movingLink)))
474: return NO; /* link not found or NULL anchor */
475: else {
476: /* First push current main link onto top of links list */
477: HTLink *newLink = (HTLink*) malloc (sizeof (HTLink));
478: if (newLink == NULL) outofmem(__FILE__, "HTAnchor_makeMainLink");
479: memcpy (newLink, & this->mainLink, sizeof (HTLink));
480: HTList_addObject (this->links, newLink);
481:
482: /* Now make movingLink the new main link, and free it */
483: memcpy (& this->mainLink, movingLink, sizeof (HTLink));
484: free (movingLink);
485: return YES;
486: }
487: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTAnchor.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src