/* Copyright 1997 Acorn Computers Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************/
/* File : TokenUtils.c */
/* */
/* Purpose: Utility functions for finding out */
/* information about tokens. */
/* */
/* Author : A.D.Hodgkinson */
/* */
/* History: 09-Apr-97: Created. */
/***************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "HTMLLib.h" /* HTML library API, Which will include html2_ext.h, tags.h and struct.h */
#include "wimp.h"
#include "wimplib.h"
#include "event.h"
#include "swis.h"
#include "kernel.h"
#include "toolbox.h"
#include "event.h"
#include "svcprint.h"
#include "Global.h"
#include "MiscDefs.h"
#include "Utils.h"
#include "Redraw.h"
#include "TokenUtils.h"
/* Locals */
static tokenutils_npaths = 0;
/* Static function prototypes */
static int tokenutils_line_range_r(int toplevel, browser_data * b, reformat_cell * d, HStream * token, int * fline, int * fchunk, int * lline, int * lchunk, token_path ** path);
/*************************************************/
/* tokenutils_anchor_range() */
/* */
/* Will return the first (inclusive) and last */
/* (inclusive) tokens that consecutively point */
/* to the same thing as anchors. This is useful */
/* as some links may be made of several tokens, */
/* as style changes to mark the result of a web */
/* search (for example) or whatever may be used */
/* in what is meant to be the same link. If this */
/* link is to be highlighted or selected, need */
/* to know which tokens are involved. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the tokens; */
/* */
/* Pointer to one of the tokens in */
/* the collection for this anchor; */
/* */
/* Pointer to an HStream pointer, */
/* into which the address of the */
/* first token involved in the link */
/* is placed; */
/* */
/* Pointer to an HStream pointer, */
/* into which the address of the */
/* last token involved in the link */
/* is placed. */
/* */
/* Assumes: Either of the last two pointers */
/* may be NULL. The token pointer */
/* given at the start should point */
/* to a link. If not, the returned */
/* addresses will be undefined... */
/*************************************************/
void tokenutils_anchor_range(browser_data * b, HStream * token, HStream ** first, HStream ** last)
{
HStream * top = NULL;
HStream * end = NULL;
HStream * store = NULL;
if (first) *first = NULL;
if (last) *last = NULL;
if (!b || !token) return;
/* Can only proceed if the given token represents a link */
if (token && (token->style & A) && token->anchor)
{
store = top = token;
/* Move up the token list for as long as the token given matches */
/* the details of the token being looked at. */
while (
top &&
(top->style & A) &&
top->anchor &&
!strcmp(top->anchor, token->anchor)
)
store = top, top = top->prev;
/* Make sure we haven't overshot the first item */
if (!top) top = store;
if (
top && !(
(top->style & A) &&
top->anchor &&
!strcmp(top->anchor, token->anchor)
)
)
top = top->next;
store = end = token;
/* Similary, move down the token list to find the first token after */
/* all those involved in the link. */
while (
end &&
(end->flags & HFlags_DealtWithToken) &&
(end->style & A) &&
end->anchor &&
!strcmp(end->anchor, token->anchor)
)
store = end, end = end->next;
/* Ensure we haven't overshot */
if (!end) end = store;
if (
end && !(
(end->flags & HFlags_DealtWithToken) &&
(end->style & A) &&
end->anchor &&
!strcmp(end->anchor, token->anchor)
)
)
end = end->prev;
}
else top = end = token;
/* Return the found values */
if (first) *first = top;
if (last) *last = end;
return;
}
/*************************************************/
/* tokenutils_line_range() */
/* */
/* Returns the first chunk and line number to */
/* use a given token, and the last line and */
/* chunk number to use that token. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the token; */
/* */
/* Pointer to the token; */
/* */
/* Pointer to an int, into which the */
/* first line number is placed; */
/* */
/* Pointer to an int, into which the */
/* first chunk number is placed; */
/* */
/* Pointer to an int, into which the */
/* last line number is placed; */
/* */
/* Pointer to an int, into which the */
/* last chunk number is placed; */
/* */
/* Pointer to a token_path pointer, */
/* which will be filled in with the */
/* address of a malloced array of */
/* reformat_cell structures for */
/* tokens within tables, or NULL if */
/* this shouldn't be built. */
/* */
/* Returns: See parameters list, and note */
/* that '-1' will be returned in all */
/* four fields should be token not */
/* be found in a line to start with; */
/* */
/* The number of entries in the */
/* associated token_path structure */
/* for table-based tokens. */
/* */
/* Assumes: Any of the pointers may be NULL. */
/*************************************************/
int tokenutils_line_range(browser_data * b, HStream * token,
int * fline, int * fchunk, int * lline, int * lchunk, token_path ** path)
{
tokenutils_npaths = 0;
if (path) *path = NULL;
return tokenutils_line_range_r(1, b, b->cell, token, fline, fchunk, lline, lchunk, path);
}
/*************************************************/
/* tokenutils_line_range_r() */
/* */
/* Recursive back-end to tokenutils_line_range. */
/* */
/* Parameters: 1 for a top level call, else 0 if */
/* being called recursively; */
/* */
/* Pointer to a browser_data struct */
/* relevant to the token; */
/* */
/* Pointer to a reformat_cell struct */
/* containing the token or a table */
/* which holds the token; */
/* */
/* Pointer to the token; */
/* */
/* Pointer to an int, into which the */
/* first line number is placed; */
/* */
/* Pointer to an int, into which the */
/* first chunk number is placed; */
/* */
/* Pointer to an int, into which the */
/* last line number is placed; */
/* */
/* Pointer to an int, into which the */
/* last chunk number is placed; */
/* */
/* Pointer to a token_path pointer, */
/* which will be filled in with the */
/* address of a malloced array of */
/* token_path structures for tokens */
/* within tables, or NULL if this */
/* shouldn't be built. */
/* */
/* Returns: As for tokenutils_line_range. */
/* */
/* Assumes: As for tokenutils_line_range. */
/*************************************************/
static int tokenutils_line_range_r(int toplevel, browser_data * b, reformat_cell * d, HStream * token,
int * fline, int * fchunk, int * lline, int * lchunk, token_path ** path)
{
int fl = -1, fc = -1, ll = -1, lc = -1; /* First Line, First Chunk, Last Line, Last Chunk */
/* Start with all values at -1; saves having to fill them */
/* in at any given failure point. */
if (fline) *fline = fl;
if (fchunk) *fchunk = fc;
if (lline) *lline = ll;
if (lchunk) *lchunk = lc;
/* Can only try to find the token if the browser_data */
/* and token pointers were not NULL. */
if (b && d && token && d->nlines)
{
int cl, cc = -1, mc; /* Current Line, Current Chunk, Maximum Chunk */
int found = 0;
/* Must find the first line / chunk even if not asked for it */
cl = 0;
/* Loop through all lines */
while (cl < d->nlines && !found)
{
cc = d->ldata[cl].chunks;
mc = cc + d->ldata[cl].n;
/* Go through this line's chunks looking for the token */
while (cc < mc && !found)
{
if (toplevel) tokenutils_npaths = 0;
if (d->cdata[cc].t == token) found = 1;
else
{
/* Must recursively scan token lists for tables */
if (d->cdata[cc].t->tagno == TAG_TABLE)
{
table_stream * table = (table_stream *) d->cdata[cc].t;
table_row * row = NULL;
table_headdata * head = NULL;
reformat_cell * cellarray = table->cells;
reformat_cell * cell;
int found = 0;
int cellindex;
int cellcount = 0;
int cellmax = table->ColSpan * table->RowSpan;
/* Naming convention: [Pointer] Table First/Last Line/Chunk */
int tfl = -1, tfc = -1, tll = -1, tlc = -1;
int * ptfl, * ptfc, * ptll, * ptlc;
if (cellarray)
{
/* For recursive scanning of line lists, keep efficiency */
/* as high as possible by only asking for the same */
/* values as originally passed to the function (e.g. */
/* don't want to look at last lines or chunks during */
/* the recursive scan unless they are needed at the top */
/* level too). */
if (fline) ptfl = &tfl;
else ptfl = NULL;
if (fchunk) ptfc = &tfc;
else ptfc = NULL;
if (lline) ptll = &tll;
else ptll = NULL;
if (lchunk) ptlc = &tlc;
else ptlc = NULL;
/* Scan the table */
row = table->List;
while (row && !found && cellcount < cellmax)
{
head = row->List;
while (head && !found && cellcount < cellmax)
{
switch (head->Tag)
{
case TagTableData:
case TagTableHead:
{
cellindex = table->ColSpan * head->RowOffs + head->ColOffs;
if (cellindex < cellmax)
{
cell = &cellarray[cellindex];
/* If a cell corresponding to this headdata item can be */
/* found and it has lines to scan, call this function */
/* recursively on its contents. */
if (cell && cell->nlines)
{
/* Move flex anchors into the temporary browser_data struct */
tokenutils_line_range_r(0,
b,
cell,
token,
ptfl,
ptfc,
ptll,
ptlc,
path);
/* Check if the token was found */
if (tfl != -1 || tfc != -1 || tll != -1 || tlc != -1) found = 1;
}
}
}
break;
}
if (!found)
{
cellcount++;
head = head->Next;
}
}
if (!found) row = row->Next;
}
if (found)
{
if (path)
{
token_path * temp;
/* Increment the tokenutils_npaths counter and allocate memory for a */
/* new token_path structure. */
tokenutils_npaths++;
/* Note 'tokenutils_npaths + 1' - an extra structure for marking the */
/* end of the array. */
if (*path) temp = realloc(*path, (tokenutils_npaths + 1) * sizeof(token_path));
else temp = malloc((tokenutils_npaths + 1) * sizeof(token_path));
/* Complain and bail out if the allocation failed */
if (!temp)
{
if (*path)
{
free(*path);
*path = NULL;
}
show_error_ret(make_no_memory_error(1));
return 0;
}
else *path = temp;
/* Fill in the new token_path structure */
(*path)[tokenutils_npaths - 1].line = cl;
(*path)[tokenutils_npaths - 1].chunk = cc;
(*path)[tokenutils_npaths - 1].head = head;
/* Fill in the terminating structure */
(*path)[tokenutils_npaths].line = -1;
(*path)[tokenutils_npaths].chunk = -1;
(*path)[tokenutils_npaths].head = NULL;
}
/* Since we've found the token within a table inside this line, */
/* and the token_path is filled in, want to exit now. */
if (fline) *fline = tfl;
if (fchunk) *fchunk = tfc;
if (lline) *lline = tll;
if (lchunk) *lchunk = tlc;
return tokenutils_npaths;
}
/* Closure of 'if (cellarray)' */
}
/* Closure of 'if (d->cdata[cc].t->tagno == TAG_TABLE)' */
}
cc++;
/* Closure of 'else' section to 'if (d->cdata[cc].t == token)' */
}
/* Closure of 'while' loop going through all the chunks */
}
/* If we haven't found a chunk yet, go to the next line */
if (!found) cl ++;
}
if (found)
{
if (cl >= d->nlines) cl = d->nlines - 1;
fl = cl, fc = cc;
/* If a line and chunk have been found, record them in fl and fc */
if (cl >= 0 && cc >= 0)
{
/* Only try to find the last line / chunk if asked for them */
if (lline || lchunk)
{
/* Start at the next line and if this starts with the given */
/* token, keep moving on until a line which doesn't start */
/* with the token is found. */
cl++;
while (cl < d->nlines && d->cdata[d->ldata[cl].chunks].t == token) cl++;
/* Coming out of the above loop either we'll be at cl = d->nlines, */
/* or cl will be the first line that doesn't start with the given */
/* token. In either case, must decrement cl by one to get back to */
/* a line which does include the token. */
cl--;
if (lchunk)
{
/* Now search the chunks for the token, starting at the last chunk */
cc = d->ldata[cl].chunks + d->ldata[cl].n - 1;
while (cc >= d->ldata[cl].chunks && d->cdata[cc].t != token) cc--;
/* If cc is still in range, a token was found on this line (it */
/* should always be, but something might go wrong above and */
/* this check is worth doing for robustness). So copy the last */
/* line and chunk details to ll and lc. */
if (cc >= d->ldata[cl].chunks) ll = cl, lc = cc;
}
else ll = cl;
}
}
}
}
/* Fill in any requested values */
if (fline) *fline = fl;
if (fchunk) *fchunk = fc;
if (lline) *lline = ll;
if (lchunk) *lchunk = lc;
return tokenutils_npaths;
}
/*************************************************/
/* tokenutils_find_ancestor_line() */
/* */
/* Returns the line in a given browser's main */
/* line list in which a given token lies, or -1 */
/* if the token can't be found. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the token and lines; */
/* */
/* Pointer to the HStream struct to */
/* find. */
/* */
/* Returns: Line number that the token lies */
/* in, in the main line list - so */
/* the token could well lie inside */
/* a table within that line. -1 is */
/* returned if the token is not */
/* found in the line list at all. */
/*************************************************/
int tokenutils_find_ancestor_line(browser_data * b, HStream * t)
{
int l;
int chunk, depth, noline = 0;
token_path * path = NULL;
depth = tokenutils_line_range(b, t, &l, &chunk, NULL, NULL, &path);
if (l < 0) noline = 1;
else
{
/* If a line was found and depth is non-zero, the line was inside */
/* a table - want to find the parent line of the table */
if (depth) l = path[depth - 1].line;
if (l < 0) noline = 1;
}
if (path) free(path);
if (noline) return -1;
return l;
}
/*************************************************/
/* tokenutils_find_token */
/* */
/* For a given token in a given reformat_cell, */
/* returns the line and chunk number that the */
/* token spans. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the token; */
/* */
/* Pointer to a reformat_cell struct */
/* containing the token or a table */
/* which holds the token; */
/* */
/* Pointer to the token; */
/* */
/* Pointer to an int, into which the */
/* first line number is placed; */
/* */
/* Pointer to an int, into which the */
/* first chunk number is placed; */
/* */
/* Pointer to an int, into which the */
/* last line number is placed; */
/* */
/* Pointer to an int, into which the */
/* last chunk number is placed; */
/* */
/* Returns: See parameters list, and note */
/* that '-1' will be returned in all */
/* four fields should be token not */
/* be found in a line to start with; */
/* */
/* Assumes: Any of the pointers may be NULL. */
/*************************************************/
void tokenutils_find_token(browser_data * b, reformat_cell * d, HStream * token, int * fline, int * fchunk, int * lline, int * lchunk)
{
int fl = -1, fc = -1, ll = -1, lc = -1; /* First Line, First Chunk, Last Line, Last Chunk */
/* Start with all values at -1; saves having to fill them */
/* in at any given failure point. */
if (fline) *fline = fl;
if (fchunk) *fchunk = fc;
if (lline) *lline = ll;
if (lchunk) *lchunk = lc;
/* Can only try to find the token if the browser_data */
/* and token pointers were not NULL. */
if (b && d && token && d->nlines)
{
int cl, cc = -1, mc; /* Current Line, Current Chunk, Maximum Chunk */
int found = 0;
/* Must find the first line / chunk even if not asked for it */
cl = 0;
/* Loop through all lines */
while (cl < d->nlines && !found)
{
cc = d->ldata[cl].chunks;
mc = cc + d->ldata[cl].n;
/* Go through this line's chunks looking for the token */
while (cc < mc && !found)
{
if (d->cdata[cc].t == token) found = 1;
/* If not found, go to the next chunk */
else cc++;
}
/* If we haven't found a chunk yet, go to the next line */
if (!found) cl ++;
}
if (found)
{
if (cl >= d->nlines) cl = d->nlines - 1;
fl = cl, fc = cc;
/* If a line and chunk have been found, record them in fl and fc */
if (cl >= 0 && cc >= 0)
{
/* Only try to find the last line / chunk if asked for them */
if (lline || lchunk)
{
/* Start at the next line and if this starts with the given */
/* token, keep moving on until a line which doesn't start */
/* with the token is found. */
cl++;
while (cl < d->nlines && d->cdata[d->ldata[cl].chunks].t == token) cl++;
/* Coming out of the above loop either we'll be at cl = d->nlines, */
/* or cl will be the first line that doesn't start with the given */
/* token. In either case, must decrement cl by one to get back to */
/* a line which does include the token. */
cl--;
if (lchunk)
{
/* Now search the chunks for the token, starting at the last chunk */
cc = d->ldata[cl].chunks + d->ldata[cl].n - 1;
while (cc >= d->ldata[cl].chunks && d->cdata[cc].t != token) cc--;
/* If cc is still in range, a token was found on this line (it */
/* should always be, but something might go wrong above and */
/* this check is worth doing for robustness). So copy the last */
/* line and chunk details to ll and lc. */
if (cc >= d->ldata[cl].chunks) ll = cl, lc = cc;
}
else ll = cl;
}
}
}
}
/* Fill in any requested values */
if (fline) *fline = fl;
if (fchunk) *fchunk = fc;
if (lline) *lline = ll;
if (lchunk) *lchunk = lc;
/* Finished */
return;
}
/*************************************************/
/* tokenutils_token_cell_offset() */
/* */
/* When a token has been found to lie in a table */
/* (tokenutils_line_range has filled in an */
/* array of token_path structures) this call */
/* can be used to quickly find the x and y */
/* offset from the top left of the main page */
/* that the line list the token was in is */
/* positioned at (i.e. for tables, the offset of */
/* the table cell the token lies in). This can */
/* be used as an origin shift for any subsequent */
/* redraws (say). */
/* */
/* External callers trying to then find the */
/* token x and y position should remember to */
/* work this out for the correct line array, */
/* which will be indicated by the first entry */
/* in the token_path array. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the token_path array; */
/* */
/* Pointer to the token_path array; */
/* */
/* Pointer to an int, in which the */
/* x offset will be written; */
/* */
/* Pointer to an int, in which the */
/* y offset will be written. */
/* */
/* Assumes: Any pointer may be NULL. If the */
/* token_path array is NULL, then */
/* an offset of 0,0 is given. */
/*************************************************/
void tokenutils_token_offset(browser_data * b, token_path * path, int * offset_x, int * offset_y)
{
int actx = 0, acty = 0;
reformat_cell * cell = b->cell;
/* Only start working things out if there's a token_path array */
if (path && tokenutils_npaths)
{
int index = tokenutils_npaths - 1;
int line, chunk;
table_stream * table;
table_headdata * head;
reformat_cell * cellarray = NULL;
reformat_cell * c = NULL;
/* Find the line, chunk, headdata structure, table structure and */
/* cell array for the last item in the token_path array. */
line = path[index].line;
chunk = path[index].chunk;
head = path[index].head;
table = (table_stream *) cell->cdata[chunk].t;
cellarray = table->cells;
/* Increment by the offset of the top left of the table. */
/* Since the last item in the array corresponds to the */
/* browser_data structure's cell array itself, here we */
/* use b->cell (stored in 'cell' above) rather than a */
/* table-derived cell. */
actx += redraw_start_x(b, cell, cell->cdata[chunk].t, line);
acty += cell->ldata[line].y + cell->ldata[line].h;
/* If there's a cell array, find the cell the current headdata */
/* item is represented by. */
if (cellarray) c = &cellarray[table->ColSpan * head->RowOffs + head->ColOffs];
/* If there's a cell, offset actx and acty by the top left */
/* hand offset of that cell. */
if (c)
{
int incx, incy;
convert_pair_to_os(c->x, c->y, &incx, &incy);
actx += incx, acty += incy;
}
/* Now do much the same for the remaining items in the token_path array */
index--;
while (index >= 0 && c && c->ldata && c->cdata)
{
line = path[index].line;
chunk = path[index].chunk;
head = path[index].head;
table = (table_stream *) c->cdata[chunk].t;
cellarray = table->cells;
actx += redraw_start_x(b, c, c->cdata[chunk].t, line);
acty += c->ldata[line].y + c->ldata[line].h;
if (cellarray) c = &cellarray[table->ColSpan * head->RowOffs + head->ColOffs];
if (c)
{
int incx, incy;
convert_pair_to_os(c->x, c->y, &incx, &incy);
actx += incx, acty += incy;
}
index--;
}
}
/* actx and acty will either have been calculated from the token_path */
/* array or will still be at 0 if no array was given. */
if (offset_x) *offset_x = actx;
if (offset_y) *offset_y = acty;
return;
}
/*************************************************/
/* tokenutils_find_cell() */
/* */
/* Examines a token_path array and returns the */
/* address of the reformat_cell structure that */
/* corresponds to the last entry. */
/* */
/* Parameters: Pointer to the reformat_cell that */
/* the token_path array refers to in */
/* the first entry (e.g. the 'cell' */
/* field of the parent browser_data */
/* structure); */
/* */
/* Number of entries in the array; */
/* */
/* Pointer to the first entry. */
/* */
/* Returns: Pointer to the reformat_cell */
/* structure corresponding to the */
/* last entry, or NULL if none may */
/* be found. */
/*************************************************/
reformat_cell * tokenutils_find_cell(reformat_cell * cell, int depth, token_path * path)
{
if (depth && path && path[0].line >= 0 && path[depth - 1].line >= 0)
{
table_stream * table;
table_headdata * head;
reformat_cell * cellarray = NULL;
reformat_cell * c = NULL;
int index = depth - 1;
int line, chunk;
/* Start looking at the token_path array. The last */
/* entry refers to the main line array, so get to */
/* the appropriate reformat_cell structure through */
/* the main line list. */
line = path[index].line;
chunk = path[index].chunk;
head = path[index].head;
table = (table_stream *) cell->cdata[chunk].t;
cellarray = table->cells;
if (cellarray) c = &cellarray[table->ColSpan * head->RowOffs + head->ColOffs];
index--;
/* Need to look at subsequent cell line arrays for any */
/* nested tables. */
while (index >= 0 && c)
{
line = path[index].line;
chunk = path[index].chunk;
head = path[index].head;
table = (table_stream *) c->cdata[chunk].t;
cellarray = table->cells;
if (cellarray) c = &cellarray[table->ColSpan * head->RowOffs + head->ColOffs];
index--;
}
return c;
}
return NULL;
}
/*************************************************/
/* tokenutils_token_cell() */
/* */
/* Returns the reformat_cell that a given token */
/* lies in. This may be NULL. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the token; */
/* */
/* Pointer to the token. */
/*************************************************/
reformat_cell * tokenutils_token_cell(browser_data * b, HStream * token)
{
table_headdata * head;
table_row * row;
table_stream * table;
reformat_cell * cellarray;
int cellnumber;
if (!b || !token) return NULL;
/* Find the table the token lies in */
head = token->parent;
if (!head) return NULL;
row = head->parent;
if (!row) return NULL;
table = row->parent;
if (!table) return NULL;
cellarray = table->cells;
if (!cellarray) return NULL;
/*�Work out what number this cell is in the cell array */
cellnumber = head->ColOffs + table->ColSpan * head->RowOffs;
if (cellnumber > table->ncells) return NULL;
else return &cellarray[cellnumber];
}
/*************************************************/
/* tokenutils_within_distance() */
/* */
/* Returns 1 if a given token is within a given */
/* distance of another, vertically. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the tokens; */
/* */
/* Pointer to the first token; */
/* */
/* Pointer to the second token; */
/* */
/* Distance that the tokens must be */
/* within. */
/* */
/* Returns: 1 if the tokens are within the */
/* given distance of each other, */
/* else 0. */
/* */
/* Assumes: If either HStream pointer is NULL */
/* the function return 1. */
/*************************************************/
int tokenutils_within_distance(browser_data * b, HStream * t1, HStream * t2, int distance)
{
int lfir1, llas1, lfir2, llas2;
int check;
reformat_cell * cell = b->cell;
if (!t1 || !t2) return 1;
/* Ensure distance is a positive number and find the */
/* lines that the tokens span. */
if (distance < 0) distance = -distance;
tokenutils_line_range(b, t1, &lfir1, NULL, &llas1, NULL, NULL);
tokenutils_line_range(b, t2, &lfir2, NULL, &llas2, NULL, NULL);
/* Special case, tokens must be at zero distance effectively */
if (lfir1 == lfir2 || llas1 == llas2) return 1;
/* Want to ensure that the maximum distance between the tokens */
/* is taken for the check. E.g. if t1 is above t2 (i.e. lfir1 */
/* is less than lfir2) then want to check the distance between */
/* the top line of t1 to the bottom line of t2. */
if (lfir1 < lfir2) check = cell->ldata[lfir1].y + cell->ldata[lfir1].h - cell->ldata[lfir2].y;
else check = cell->ldata[lfir2].y + cell->ldata[lfir2].h - cell->ldata[lfir1].y;
return (check <= distance);
}