/* * Copyright (c) 2002, The Tendra Project * 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 unmodified, 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. * * * 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. * * $TenDRA: tendra/src/tools/tnc/alignment.c,v 1.8 2005/09/21 20:30:00 stefanf Exp $ */ #include "config.h" #include "msgcat.h" #include "types.h" #include "alignment.h" #include "check.h" #include "node.h" #include "shape.h" #include "table.h" #include "tdf.h" #include "utility.h" /* * BASIC ALIGNMENTS * * These are the basic alignments from the TDF specification. */ node *al_code = null; node *al_frame = null; node *al_alloca = null; node *al_var_param = null; node *al_top = null; static node *al_offset = null; static node *al_pointer = null; static node *al_proc = null; /* * FIND THE ALIGNMENT OF A SHAPE * * For the node p, representing a shape or an alignment, this returns * the alignment of p. */ node * al_shape(node *p) { node *q; sortname s; if (p == null) return (null); s = p->cons->sortnum; if (s == SORT_alignment) { switch (p->cons->encoding) { case ENC_alignment : { return (al_shape (p->son)); } case ENC_alignment_apply_token : { return (al_shape (expand_tok (p))); } } return (copy_node (p)); } if (s == SORT_shape) { switch (p->cons->encoding) { case ENC_bottom : { MSG_cant_have_alignment_of_bottom_in (checking); return (null); } case ENC_offset : return (copy_node (al_offset)); case ENC_pointer : return (copy_node (al_pointer)); case ENC_proc : return (copy_node (al_proc)); case ENC_top : return (copy_node (al_top)); case ENC_nof : return (al_shape (p->son->bro)); case ENC_shape_apply_token : { return (al_shape (expand_tok (p))); } } } q = new_node (); q->cons = cons_no (SORT_alignment, ENC_alignment); q->son = copy_node (p); return (null); } /* * FIND WHAT A POINTER POINTS TO * * For the node p of the form (pointer a) this routine returns a. */ node * ptr_to(node *p) { p = expand_tok (p); if (p && p->cons == cons_no (SORT_shape, ENC_pointer)) { return (p->son); } return (null); } /* * FIND THE FIRST COMPONENT OF AN OFFSET * * For the node p of the form (offset a b) this routine returns a. */ node * offset_from(node *p) { p = expand_tok (p); if (p && p->cons == cons_no (SORT_shape, ENC_offset)) { return (p->son); } return (null); } /* * FIND THE SECOND COMPONENT OF AN OFFSET * * For the node p of the form (offset a b) this routine returns b. */ node * offset_to(node *p) { p = expand_tok (p); if (p && p->cons == cons_no (SORT_shape, ENC_offset)) { return (p->son->bro); } return (null); } /* * CHECK THAT TWO ALIGNMENTS ARE EQUAL * * This routine is not yet implemented. */ void al_equals(node *p, node *q) { UNUSED (p); UNUSED (q); return; } /* * CHECK THAT ONE ALIGNMENT CONTAINS ANOTHER * * This routine is not yet implemented. */ void al_includes(node *p, node *q) { UNUSED (p); UNUSED (q); return; } /* * FIND THE UNIONS OF TWO ALIGNMENTS * * The value of (unite_alignments p q) is returned. */ node * al_union(node *p, node *q) { if (p == null || p->cons->sortnum != SORT_alignment) return (null); if (q == null || q->cons->sortnum != SORT_alignment) return (null); if (p->cons->encoding == ENC_alignment && p->son->cons == cons_no (SORT_shape, ENC_top)) return (q); if (q->cons->encoding == ENC_alignment && q->son->cons == cons_no (SORT_shape, ENC_top)) return (p); return (null); } /* * INITIALIZE BASIC ALIGNMENTS * * The basic alignments, al_top, al_offset, al_pointer and al_proc, are * initialized. */ void init_alignments(void) { /* Set up al_top */ al_top = new_node (); al_top->cons = cons_no (SORT_alignment, ENC_alignment); al_top->son = copy_node (sh_top); /* Set up al_offset */ al_offset = new_node (); al_offset->cons = cons_no (SORT_alignment, ENC_alignment); al_offset->son = sh_offset (al_top, al_top); /* Set up al_pointer */ al_pointer = new_node (); al_pointer->cons = cons_no (SORT_alignment, ENC_alignment); al_pointer->son = sh_pointer (al_top); /* Set up al_proc */ al_proc = new_node (); al_proc->cons = cons_no (SORT_alignment, ENC_alignment); al_proc->son = copy_node (sh_proc); return; }