home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gnat-2.06-src.tgz / tar.out / fsf / gnat / ada / a-trans4.h < prev    next >
C/C++ Source or Header  |  1996-09-28  |  5KB  |  91 lines
  1. /****************************************************************************/
  2. /*                                                                          */
  3. /*                         GNAT COMPILER COMPONENTS                         */
  4. /*                                                                          */
  5. /*                             A - T R A N S 4                              */
  6. /*                                                                          */
  7. /*                              C Header File                               */
  8. /*                                                                          */
  9. /*                            $Revision: 1.27 $                             */
  10. /*                                                                          */
  11. /*           Copyright (c) 1992,1993,1994 NYU, All Rights Reserved          */
  12. /*                                                                          */
  13. /* GNAT is free software;  you can  redistribute it  and/or modify it under */
  14. /* terms of the  GNU General Public License as published  by the Free Soft- */
  15. /* ware  Foundation;  either version 2,  or (at your option) any later ver- */
  16. /* sion.  GNAT is distributed in the hope that it will be useful, but WITH- */
  17. /* OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY */
  18. /* or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License */
  19. /* for  more details.  You should have  received  a copy of the GNU General */
  20. /* Public License  distributed with GNAT;  see file COPYING.  If not, write */
  21. /* to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  22. /*                                                                          */
  23. /****************************************************************************/
  24.  
  25. /* Prepare expr to be an argument of a TRUTH_NOT_EXPR or other logical
  26.    operation.
  27.  
  28.    This preparation consists of taking the ordinary
  29.    representation of an expression expr and producing a valid tree
  30.    boolean expression describing whether expr is nonzero.  We could
  31.    simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
  32.    but we optimize comparisons, &&, ||, and !.
  33.  
  34.    The resulting type should always be the same as the input type.
  35.    This function is simpler than the corresponding C version since
  36.    the only possible operands will be things of Boolean type.  */
  37. extern tree truthvalue_conversion      PROTO((tree));
  38.  
  39. /* Return the base type of TYPE.  */
  40.  
  41. extern tree get_base_type    PROTO((tree));
  42.  
  43. /* Make a binary operation of kind OP_CODE.  RESULT_TYPE is the type
  44.    desired for the result.  Usually the operation is to be performed
  45.    in that type.  For MODIFY_EXPR and ARRAY_REF, RESULT_TYPE may be 0
  46.    in which case the type to be used will be derived from the operands.  */
  47. extern tree build_binary_op    PROTO((enum tree_code, tree, tree, tree));
  48.  
  49. /* Similar, but make unary operation.   */
  50. extern tree build_unary_op    PROTO((enum tree_code, tree, tree));
  51.  
  52. /* Similar, but for COND_EXPR.  */
  53. extern tree build_cond_expr    PROTO((tree, tree, tree, tree));
  54.  
  55. /* Build a CALL_EXPR to call FUNDECL with one argument, ARG.  Return
  56.    the CALL_EXPR.  */
  57. extern tree build_call_1_expr    PROTO((tree, tree));
  58.  
  59. /* Likewise to call FUNDECL with no arguments.  */
  60. extern tree build_call_0_expr    PROTO((tree));
  61.  
  62. /* Return a CONSTRUCTOR of TYPE whose list is LIST.  */
  63. extern tree build_constructor    PROTO((tree, tree));
  64.  
  65. /* Return a COMPONENT_REF to access a field that is given by COMPONENT,
  66.    an IDENTIFIER_NODE giving the name of the field, FIELD, a FIELD_DECL,
  67.    for the field, or both.  */
  68. extern tree build_component_ref    PROTO((tree, tree, tree));
  69.  
  70. /* Build a GCC tree to call an allocation or deallocation function.
  71.    If GNU_OBJ is nonzero, it is an object to deallocate.  Otherwise,
  72.    genrate an allocator.
  73.  
  74.    GNU_SIZE is the size of the object and ALIGN is the alignment.
  75.    GNAT_PROC, if present is a procedure to call and GNAT_POOL is the
  76.    storage pool to use.  If not preset, malloc and free will be used.  */
  77. extern tree build_call_alloc_dealloc PROTO((tree, tree, int, Entity_Id,
  78.                         Entity_Id));
  79.  
  80. /* Build a GCC tree to correspond to allocating an object of TYPE whose
  81.    initial value if INIT, if INIT is nonzero.  Convert the expression to
  82.    RESULT_TYPE, which must be some type of pointer.  Return the tree. 
  83.    GNAT_PROC and GNAT_POOL optionally give the procedure to call and
  84.    the storage pool to use.  */
  85. extern tree build_allocator    PROTO((tree, tree, tree, Entity_Id,
  86.                        Entity_Id));
  87.  
  88. /* Indicate that we need to make the address of EXPR_NODE and it therefore
  89.    should not be allocated in a register. Return 1 if successful.  */
  90. extern int mark_addressable    PROTO((tree));
  91.