Rev 6 | Blame | Compare with Previous | Last modification | View Log | RSS feed
/*
* Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of The TenDRA Project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific, prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*/
/*
Crown Copyright (c) 1997
This TenDRA(r) Computer Program is subject to Copyright
owned by the United Kingdom Secretary of State for Defence
acting through the Defence Evaluation and Research Agency
(DERA). It is made available to Recipients with a
royalty-free licence for its use, reproduction, transfer
to other parties and amendment for any purpose not excluding
product development provided that any such use et cetera
shall be deemed to be acceptance of the following conditions:-
(1) Its Recipients shall ensure that this Notice is
reproduced upon any copies or amended versions of it;
(2) Any amended version of it shall be clearly marked to
show both the nature of and the organisation responsible
for the relevant amendment or amendments;
(3) Its onward transfer from a recipient to another
party shall be deemed to be that party's acceptance of
these conditions;
(4) DERA gives no warranty or assurance as to its
quality or suitability for any purpose and DERA accepts
no liability whatsoever in relation to any use to which
it may be put.
*/
#include "config.h"
#include "types.h"
#include "node.h"
#include "table.h"
#include "tdf.h"
#include "utility.h"
/*
LIST OF FREE NODES
Nodes are allocated from this list.
*/
static node *free_nodes = null;
/*
CREATE A NEW NODE
A new node is created and its fields cleared.
*/
node *
new_node(void)
{
node *p = free_nodes;
if (p == null) {
int i, m = 1000;
p = alloc_nof(node, m);
for (i = 0; i < m - 1; i++) {
(p + i) ->bro = p + (i + 1);
(p + i) ->son = null;
}
(p + (m - 1)) ->bro = null;
(p + (m - 1)) ->son = null;
free_nodes = p;
}
free_nodes = p->bro;
p->cons = null;
p->son = null;
p->bro = null;
p->shape = null;
return(p);
}
/*
FREE A NODE
The node p is recursively returned to the free list.
*/
void
free_node(node *p)
{
while (p) {
node *q = p->bro;
if (p->son)free_node(p->son);
p->bro = free_nodes;
free_nodes = p;
p = q;
}
return;
}
/*
FORM THE COMPLETION OF A NODE
The completion of the node p is created. This consists of p itself
and the list of all local variable sorts created during the
construction of p, as recorded by the removals list.
*/
node *
completion(node *p)
{
node *q = new_node();
construct *v = make_construct(SORT_completion);
v->next = removals;
removals = null;
q->cons = v;
q->son = p;
return(q);
}
/*
AUXILIARY EQUALITY ROUTINE
This routine checks the nodes p and q for equality modulo the
lists of local variables ap and aq (which are known to correspond).
*/
static boolean
eq_node_aux(node *p, node *q, construct *ap, construct *aq, int args)
{
while (p != null && q != null) {
if (p->cons != q->cons) {
sortname s = p->cons->sortnum;
if (s != q->cons->sortnum) return(0);
switch (s) {
case SORT_bytestream:
case SORT_option: {
/* Just check son */
break;
}
case SORT_tdfbool:
case SORT_small_tdfint:
case SORT_repeat: {
/* Check value or number of repeats */
if (p->cons->encoding != q->cons->encoding) {
return(0);
}
break;
}
case SORT_tdfint:
case SORT_tdfstring: {
/* Check value */
if (!streq(p->cons->name, q->cons->name)) {
return(0);
}
break;
}
default : {
/* Check lists of local variables */
boolean ok = 0;
construct *xp = ap;
construct *xq = aq;
while (xp && !ok) {
if (xp == p->cons && xq == q->cons)ok = 1;
xp = xp->next;
xq = xq->next;
}
if (!ok) return(0);
break;
}
}
}
if (!eq_node_aux(p->son, q->son, ap, aq, 1)) return(0);
if (!args) return(1);
p = p->bro;
q = q->bro;
}
if (p == q) return(1);
return(0);
}
/*
CHECK TWO LISTS OF CONSTRUCTS
The lists of local variables ap and aq are checked to have the
same length and corresponds sorts in each position.
*/
static boolean
eq_cons_list(construct *ap, construct *aq)
{
while (ap != null && aq != null) {
if (ap->sortnum != aq->sortnum) return(0);
ap = ap->next;
aq = aq->next;
}
if (ap == aq) return(1);
return(0);
}
/*
FLAG : SHOULD WE CHECK EQUALITY OF NODES?
This should be set to 1 to suppress the check in eq_node.
*/
boolean dont_check = 0;
/*
ARE TWO NODES EQUAL?
The nodes p and q are checked for equality.
*/
boolean
eq_node(node *p, node *q)
{
construct *ap = null;
construct *aq = null;
if (dont_check) return(1);
if (p == q) return(1);
if (p == null || q == null) return(0);
if (p->cons->sortnum == SORT_completion) {
ap = p->cons->next;
p = p->son;
}
if (q->cons->sortnum == SORT_completion) {
aq = q->cons->next;
q = q->son;
}
if (!eq_cons_list(ap, aq)) return(0);
return(eq_node_aux(p, q, ap, aq, 0));
}
/*
LIST OF FREE CONSTRUCTS
Constructs are allocated from this list.
*/
static construct *free_constructs = null;
/*
CREATE A NEW CONSTRUCT
A new construct is allocated. Its fields are not initialized.
*/
construct *
new_construct(void)
{
construct *p = free_constructs;
if (p == null) {
int i, m = 100;
p = alloc_nof(construct, m);
for (i = 0; i < m - 1; i++)(p + i) ->next = p + (i + 1);
(p + (m - 1)) ->next = null;
free_constructs = p;
}
free_constructs = p->next;
p->alias = null;
p->next = null;
return(p);
}
/*
CREATE A NEW CONSTRUCT OF A GIVEN SORT
A new construct is allocated. Its fields are initialized for a
construct of sort s.
*/
construct *
make_construct(sortname s)
{
construct *p = new_construct();
p->sortnum = s;
if (s >= 0) {
p->encoding = (sort_count[s]) ++;
} else {
p->encoding = 0;
}
p->name = null;
p->ename = null;
p->next = null;
switch (s) {
case SORT_al_tag: {
/* Initialize alignment tag */
al_tag_info *q = get_al_tag_info(p);
q->def = null;
break;
}
case SORT_tag: {
/* Initialize tag */
tag_info *q = get_tag_info(p);
q->var = 3;
q->vis = 0;
q->dec = null;
q->def = null;
break;
}
case SORT_token: {
/* Initialize token */
tok_info *q = get_tok_info(p);
q->dec = 0;
q->res = SORT_unknown;
q->args = null;
q->sig = null;
q->def = null;
q->pars = null;
q->depth = 0;
break;
}
}
return(p);
}
/*
FREE A LIST OF CONSTRUCTS
The list of constructed pointed to by p is returned to free.
*/
void
free_construct(construct **p)
{
construct *q = *p;
if (q) {
while (q->next)q = q->next;
q->next = free_constructs;
free_constructs = *p;
}
*p = null;
return;
}
/*
SET THE SORT OF A TOKEN
The token construct p is set to have result sort rs and argument
sorts args.
*/
void
set_token_sort(construct *p, sortname rs, char *args, node *sig)
{
tok_info *info = get_tok_info(p);
if (info->res != SORT_unknown) {
boolean error = 0;
if (info->res != rs)error = 1;
if (args) {
if (info->args == null || !streq(args, info->args)) {
error = 1;
}
} else {
if (info->args)error = 1;
}
if (error) {
is_fatal = 0;
input_error("Token %s declared inconsistently", p->name);
}
}
info->res = rs;
info->args = args;
info->sig = sig;
return;
}
/*
SET TAG TYPE
The tag construct p is set to be a variable or an identity, depending
on the flag is_var.
*/
void
set_tag_type(construct *p, int is_var)
{
tag_info *info = get_tag_info(p);
if (info->var != 3) {
if (info->var != is_var) {
is_fatal = 0;
input_error("Tag %s declared inconsistently", p->name);
}
}
#if 0
info->var = is_var;
#endif
return;
}
/*
CREATE A COPY OF A CONSTRUCT
This routine creates a copy of the construct p. This is used during
token expansion to ensure that tags and labels which are local to a
token definition are handled correctly.
*/
void
copy_construct(construct *p)
{
sortname s = p->sortnum;
construct *q = make_construct(s);
if (s == SORT_tag) {
tag_info *pi = get_tag_info(p);
tag_info *qi = get_tag_info(q);
qi->var = pi->var;
qi->vis = pi->vis;
}
q->name = p->name;
p->alias = q;
(sort_removed[s]) ++;
return;
}
/*
SKIP TEXT ENCLOSED IN SQUARE BRACKETS
The decode string s is analysed and a pointer to the first ']'
which is not balanced by a '[' is returned.
*/
char *
skip_text(char *s)
{
int n = 0;
while (*s) {
if (*s == '[')n++;
if (*s == ']') {
if (n == 0) return(s);
n--;
}
s++;
}
fatal_error("Illegal decoding string");
return(s);
}
/*
LOCAL IDENTIFIER PREFIX
All tag, token and alignment tags with this prefix are treated as if
they were declared local.
*/
char *local_prefix = "<none>";
/*
IS AN IDENTIFIER LOCAL?
This routine checks whether the identifier name s begins with the
local identifier prefix above.
*/
boolean
is_local_name(char *s)
{
char *t = local_prefix;
while (*s == *t) {
s++;
t++;
}
if (*t == 0) return(1);
return(0);
}