earlybrowserreborn - Blame information for rev 2

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 roytam 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  
2 roytam 88 HTChildAnchor * HTAnchor_findChild
1 roytam 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) printf("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) printf("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) printf("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 extern 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 }