Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

file 133 lines (105 sloc) 4.913 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
/* Language-level data type conversion for GNU C.
Copyright (C) 1987, 1988, 1991, 1998, 2002 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
   
   
/* This file contains the functions for converting C expressions
to different data types. The only entry point is `convert'.
Every language front end must have a `convert' function
but what kind of conversions it does will depend on the language. */
        
/* copied from the f77 frontend I think */
     
/* copied from c-convert.c without significant modification*/
/* Change of width--truncation and extension of integers or reals--
is represented with NOP_EXPR. Proper functioning of many things
assumes that no other conversions can be NOP_EXPRs.
*/
 
/* I've added support for WITH_RECORD_EXPR. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "flags.h"
#include "convert.h"
#include "c-common.h"
#include "toplev.h"
#include "g95-support.h"
    
/*
Conversion between integer and pointer is represented with CONVERT_EXPR.
Converting integer to real uses FLOAT_EXPR
and real to integer uses FIX_TRUNC_EXPR.

Here is a list of all the functions that assume that widening and
narrowing is always done with a NOP_EXPR:
In convert.c, convert_to_integer.
In c-typeck.c, build_binary_op (boolean ops), and
c_common_truthvalue_conversion.
In expr.c: expand_expr, for operands of a MULT_EXPR.
In fold-const.c: fold.
In tree.c: get_narrower and get_unwidened. */
  
/* Subroutines of `convert'. */
         
/* Create an expression whose value is that of EXPR,
converted to type TYPE. The TREE_TYPE of the value
is always TYPE. This function implements all reasonable
conversions; callers should filter out those that are
not permitted by the language being compiled. */
          
/* We are assuming that given a SIMPLE val, the result will be a SIMPLE rhs.
If this is not the case, we will abort with an internal error. */
  
tree convert (tree type, tree expr) {
  tree e = expr;
  enum tree_code code = TREE_CODE(type);
 
  if (TREE_CODE (expr) == WITH_RECORD_EXPR)
    return build(WITH_RECORD_EXPR, type,
convert(type, TREE_OPERAND(expr, 0)),
TREE_OPERAND(expr, 1));
          
  if (type == TREE_TYPE(expr)
      || TREE_CODE(expr) == ERROR_MARK
      || code == ERROR_MARK || TREE_CODE(TREE_TYPE(expr)) == ERROR_MARK)
    return expr;
        
  if (TYPE_MAIN_VARIANT(type) == TYPE_MAIN_VARIANT(TREE_TYPE(expr)))
    return fold(build1(NOP_EXPR, type, expr));
   
  if (TREE_CODE(TREE_TYPE(expr)) == ERROR_MARK)
    return error_mark_node;
 
  if (TREE_CODE(TREE_TYPE (expr)) == VOID_TYPE) {
    error ("void value not ignored as it ought to be");
    return error_mark_node;
  }
       
  if (code == VOID_TYPE)
    return build1(CONVERT_EXPR, type, e);
#if 0
/* This is incorrect. A truncation can't be stripped this way.
Extensions will be stripped by the use of get_unwidened. */
if (TREE_CODE(expr) == NOP_EXPR)
return convert(type, TREE_OPERAND(expr, 0));
#endif
  if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
    return fold(convert_to_integer(type, e));
   
  if (code == BOOLEAN_TYPE) {
    tree t = g95_truthvalue_conversion(expr);
    /* If it returns a NOP_EXPR, we must fold it here to avoid
infinite recursion between fold () and convert (). */
    if (TREE_CODE(t) == NOP_EXPR)
      return fold(build1(NOP_EXPR, type, TREE_OPERAND(t, 0)));
    else
      return fold(build1(NOP_EXPR, type, t));
  }
   
  if (code == POINTER_TYPE || code == REFERENCE_TYPE)
    return fold(convert_to_pointer (type, e));
          
  if (code == REAL_TYPE)
    return fold(convert_to_real (type, e));
  
  if (code == COMPLEX_TYPE)
    return fold(convert_to_complex (type, e));
   
  if (code == VECTOR_TYPE)
    return fold(convert_to_vector (type, e));
  
  error ("conversion to non-scalar type requested");
  return error_mark_node;
}
Something went wrong with that request. Please try again.