Open64: osprey/be/whirl2c/tcon2c.cxx Source File

00001 /*
00002  * Copyright 2003, 2004 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /*
00006 
00007   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00008 
00009   This program is free software; you can redistribute it and/or modify it
00010   under the terms of version 2 of the GNU General Public License as
00011   published by the Free Software Foundation.
00012 
00013   This program is distributed in the hope that it would be useful, but
00014   WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00016 
00017   Further, this software is distributed without any warranty that it is
00018   free of the rightful claim of any third person regarding infringement 
00019   or the like.  Any license provided herein, whether implied or 
00020   otherwise, applies only to this software file.  Patent licenses, if 
00021   any, provided herein do not apply to combinations of this program with 
00022   other software, or any other product whatsoever.  
00023 
00024   You should have received a copy of the GNU General Public License along
00025   with this program; if not, write the Free Software Foundation, Inc., 59
00026   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00027 
00028   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00029   Mountain View, CA 94043, or:
00030 
00031   http://www.sgi.com
00032 
00033   For further information regarding this notice, see:
00034 
00035   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00036 
00037 */
00038 
00039 
00040 /* ====================================================================
00041  * ====================================================================
00042  *
00043  * Module: tcon2c.c
00044  * $Revision: 1.1.1.1 $
00045  * $Date: 2005/10/21 19:00:00 $
00046  * $Author: marcel $
00047  * $Source: /proj/osprey/CVS/open64/osprey1.0/be/whirl2c/tcon2c.cxx,v $
00048  *
00049  * Revision history:
00050  *  07-Nov-94 - Original Version
00051  *
00052  * Description:
00053  *
00054  *    See tcon2c.h for a description of the exported functions and 
00055  *    variables.
00056  *
00057  * ====================================================================
00058  * ====================================================================
00059  */
00060 #ifdef _KEEP_RCS_ID
00061 static char *rcs_id = "$Source: /proj/osprey/CVS/open64/osprey1.0/be/whirl2c/tcon2c.cxx,v $ $Revision: 1.1.1.1 $";
00062 #endif /* _KEEP_RCS_ID */
00063 
00064 #include <ctype.h>
00065 #include "whirl2c_common.h"
00066 #include "tcon2c.h"
00067 #include "alloca.h"
00068 
00069 /*---------------------- Hidden utilities ---------------------*/
00070 /*-------------------------------------------------------------*/
00071   
00072 static const char *
00073 Remove_Trailing_Zero_Fraction(char *strbase)
00074 {
00075    /* Expect the input to be of the form: "d.dddde+dd", where a '-' may 
00076     * occur in place of the '+', or the '+' could be omitted.  We view the
00077     * 'e' as any letter.
00078     */
00079    INT last, i;
00080 
00081    /* Get to the first digit from the right, which is non-zero.
00082     */
00083    for (last = 0; strbase[last] != '\0'; last++);
00084    for (i = last-1; strbase[i] == '0'; i--);
00085 
00086    /* Remove any unnecesary exponent part and the trailing zeros in the
00087     * fractional part.
00088     */
00089    if (strbase[i] < '0' || strbase[i] > '9')
00090    {
00091       while (strbase[i] < '0' || strbase[i] > '9') i--;
00092       while (strbase[i] == '0') i--;
00093       if (strbase[i] == '.')
00094       {
00095    strbase[i+1] = '0';
00096    last = i+2;
00097       }
00098       else
00099       {
00100    last = i+1;
00101       }
00102    }
00103    else
00104    {
00105       INT j, remove_to;
00106       INT skip = 1;
00107 
00108       while (strbase[i] >= '0' && strbase[i] <= '9') i--; /* skip exp digits */
00109       if(strbase[i] == '.')
00110         skip = 0;
00111       while (strbase[i] < '0' || strbase[i] > '9') i--; /* skip exp letters */
00112       remove_to = i;
00113 
00114       while (skip && strbase[i] == '0') i--; /* skip zero digits in the fraction */
00115       if (strbase[i] == '.')
00116    i += 1;
00117 
00118       /* Move exponent part up till just after the non-zero fractional part
00119        */
00120       for (j = remove_to+1; j < last; j++)
00121    strbase[++i] = strbase[j];
00122       last = i+1;
00123    }
00124    //do not delete 0.0
00125    if(last)
00126      strbase[last] = '\0';
00127 
00128    return strbase;
00129 } /* Remove_Trailing_Zero_Fraction */
00130 
00131 char* append_char(char* str, char ch)
00132 {
00133   BOOL escape;
00134   char escaped_ch;
00135 
00136   switch (ch)
00137   {
00138   case '\n':
00139      escaped_ch = 'n';
00140      escape = TRUE;
00141      break;
00142   case '\t':
00143     escaped_ch = 't';
00144     escape = TRUE;
00145     break;
00146   case '\a':
00147     escaped_ch = 'a';
00148     escape = TRUE;
00149     break;
00150   case '\b':
00151      escaped_ch = 'b';
00152      escape = TRUE;
00153      break;
00154   case '\r':
00155      escaped_ch = 'r';
00156      escape = TRUE;
00157      break;
00158   case '\f':
00159      escaped_ch = 'f';
00160      escape = TRUE;
00161      break;
00162   case '\v':
00163      escaped_ch = 'v';
00164      escape = TRUE;
00165      break;
00166   case '\\':
00167      escaped_ch = '\\';
00168      escape = TRUE;
00169      break;
00170   case '\'':
00171      escaped_ch = '\'';
00172      escape = TRUE;
00173      break;
00174   case '\"':
00175      escaped_ch = '\"';
00176      escape = TRUE;
00177      break;
00178   default:
00179     if (!isprint(ch)) {
00180       /* special handling for binary output */
00181       *str++ = '\\';
00182       //const char * val = utoa(ch).c_str();
00183       char val[4];
00184       sprintf(val, "%u", ch);
00185       for (int i = 0; i < strlen(val); i++) {
00186         *str++ = val[i];
00187       }
00188       return str;
00189     } else {
00190       escaped_ch = ch;
00191       escape = FALSE;
00192     }
00193      break;
00194   }
00195   if (escape)
00196      *str++ = '\\';
00197   *str++ = escaped_ch;
00198 
00199   return str;
00200 }
00201 
00202 void 
00203 TCON2C_Append_String_Const(TOKEN_BUFFER tokens, 
00204          const char  *orig_str, 
00205          INT32        strlen)
00206 {
00207    const char *str_base;
00208    char       *str;
00209    INT32       stridx;
00210 
00211    str_base = str = (char *)alloca(2*strlen + 3); /* "'", orig_str, "'", and "\0" */
00212    *(str++) = '\"';
00213    strlen = strlen - 1; // subtract 1 for the extra \0
00214    for (stridx = 0; stridx < strlen; stridx++)
00215       str = append_char(str, orig_str[stridx]);
00216    while (str[-1] == '\0') str--;
00217    *(str++) = '\"';
00218    *(str++) = '\0';
00219    Append_Token_String(tokens, str_base);
00220 } /* TCON2C_Append_String_Const */
00221 
00222 
00223 /*---------------------- Exported functions -------------------*/
00224 /*-------------------------------------------------------------*/
00225 
00226 void 
00227 TCON2C_initialize(void)
00228 {
00229    return; /* do nothing for now */
00230 } /* TCON2C_initialize */
00231 
00232 
00233 void 
00234 TCON2C_finalize(void)
00235 {
00236    return; /* do nothing for now */
00237 } /* TCON2C_finalize */
00238 
00239 
00240 void 
00241 TCON2C_translate(TOKEN_BUFFER tokens, TCON tvalue)
00242 {
00243    const char  *strbase;
00244    char        *str;
00245    INT32        max_strlen, strlen, stridx;
00246    
00247    switch (TCON_ty(tvalue))
00248    {
00249    case MTYPE_STR:
00250       max_strlen = (Get_Maximum_Linelength()*2)/3;
00251       strlen = Targ_String_Length(tvalue);
00252       strbase = Targ_String_Address(tvalue);
00253       if (max_strlen > 0 && max_strlen < strlen)
00254       {
00255    /* We need to split the string constant into substrings */
00256    str = (char *)alloca(max_strlen + 1);
00257    while (strlen > max_strlen)
00258    {
00259       for (stridx = 0; stridx < max_strlen; stridx++)
00260          str[stridx] = strbase[stridx];
00261       str[stridx] = '\0';
00262       strbase = &strbase[stridx];
00263       strlen -= max_strlen;
00264       TCON2C_Append_String_Const(tokens, str, max_strlen);
00265    }
00266       }
00267       TCON2C_Append_String_Const(tokens, strbase, strlen);
00268       break;
00269 
00270     case MTYPE_I1:
00271     case MTYPE_I2:
00272     case MTYPE_I4:
00273       Append_Token_String(tokens, Targ_Print("%1d", tvalue));
00274       break;
00275       
00276     case MTYPE_B:
00277     case MTYPE_U1:
00278     case MTYPE_U2:
00279     case MTYPE_U4:
00280       Append_Token_String(tokens, Targ_Print("%1uU", tvalue));
00281       break;
00282 
00283     case MTYPE_I8:
00284       Append_Token_String(tokens, Targ_Print("%1lldLL", tvalue));
00285       break;
00286 
00287     case MTYPE_U8:
00288       Append_Token_String(tokens, Targ_Print("%1lluULL", tvalue));
00289       break;
00290 
00291     case MTYPE_F4:
00292       str = Targ_Print("%.10e", tvalue);
00293       strbase = Remove_Trailing_Zero_Fraction(str);
00294       /* Undo the 'e'->'d' conversion */
00295       if ((str = strchr(strbase, 'd')) != NULL)
00296    *str = 'e';
00297 
00298       /* Add F suffix */
00299       Append_Token_String(tokens, Concat2_Strings(strbase, "F"));
00300       break;
00301 
00302     case MTYPE_F8:
00303       str = Targ_Print("%.20e", tvalue);
00304       strbase = Remove_Trailing_Zero_Fraction(str);
00305       /* Undo the 'e'->'d' conversion */
00306       if ((str = strchr(strbase, 'd')) != NULL)
00307    *str = 'e';
00308       Append_Token_String(tokens, strbase);
00309       break;
00310 
00311     case MTYPE_F10:
00312       str = Targ_Print(NULL, tvalue);
00313       strbase = Remove_Trailing_Zero_Fraction(str);
00314       /* Undo the 'e'->'d' conversion */
00315       if ((str = strchr(strbase, 'd')) != NULL)
00316          *str = 'e';
00317       Append_Token_String(tokens, strbase);
00318       break;
00319 
00320     case MTYPE_FQ:
00321       str = Targ_Print(NULL, tvalue);
00322       strbase = Remove_Trailing_Zero_Fraction(str);
00323       /* Undo the 'e'->'d' conversion */
00324       if ((str = strchr(strbase, 'd')) != NULL)
00325    *str = 'e'; 
00326 
00327       /* Add L suffix */
00328       Append_Token_String(tokens, Concat2_Strings(strbase, "L"));
00329       break;
00330 
00331     case MTYPE_C4:
00332     case MTYPE_C8:
00333     case MTYPE_C10:
00334     case MTYPE_CQ:
00335       Append_Token_Special(tokens, '{');
00336       TCON2C_translate(tokens, Extract_Complex_Real(tvalue));
00337       Append_Token_Special(tokens, ',');
00338       TCON2C_translate(tokens, Extract_Complex_Imag(tvalue));
00339       Append_Token_Special(tokens, '}');
00340       break;
00341 
00342 #ifdef TARG_X8664
00343    case MTYPE_V16I1: {
00344      char *newstr;
00345      str = Targ_Print("%1d", tvalue);
00346      newstr = (char *)malloc(sizeof(char)*2000); //((strlen(str)+1)*16+15));
00347      sprintf(newstr, 
00348      "[%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s]", 
00349        str, str, str, str, str, str, str, str, 
00350        str, str, str, str, str, str, str, str);
00351      Append_Token_String(tokens, newstr);
00352      break;
00353    }
00354    case MTYPE_V16I2: {
00355      char *newstr;
00356      str = Targ_Print("%1d", tvalue);
00357      newstr = (char *)malloc(sizeof(char)*1000); //((strlen(str)+1)*4+15));
00358      sprintf(newstr, "[%s, %s, %s, %s, %s, %s, %s, %s]", 
00359        str, str, str, str, str, str, str, str);
00360      Append_Token_String(tokens, newstr);
00361      break;
00362    }
00363    case MTYPE_V16I4: {
00364      char *newstr;
00365      str = Targ_Print("%1d", tvalue);
00366      newstr = (char *)malloc(sizeof(char)*1000); //((strlen(str)+1)*4+15));
00367      sprintf(newstr, "[%s, %s, %s, %s]", 
00368        str, str, str, str);
00369      Append_Token_String(tokens, newstr);
00370      break;
00371    }
00372    case MTYPE_V16I8: {
00373      char *newstr;
00374      str = Targ_Print("%1lldLL", tvalue);
00375      newstr = (char *)malloc(sizeof(char)*1000); //((strlen(strbase)+1)*2+15));
00376      sprintf(newstr, "[%s, %s]", str, str);
00377      Append_Token_String(tokens, newstr);
00378      break;
00379    }
00380    case MTYPE_V16F4: {
00381      char *newstr;
00382      str = Targ_Print("%.10e", tvalue);
00383      strbase = Remove_Trailing_Zero_Fraction(str);
00384      /* Undo the 'e'->'d' conversion */
00385      if ((str = strchr(strbase, 'd')) != NULL)
00386        *str = 'e';
00387      
00388      newstr = (char *)malloc(sizeof(char)*1000); //((strlen(strbase)+1)*4+15));
00389      sprintf(newstr, "[%sF, %sF, %sF, %sF]", 
00390        strbase, strbase, strbase, strbase);
00391      Append_Token_String(tokens, newstr);
00392      break;
00393    }
00394    case MTYPE_V16F8: {
00395      char *newstr;
00396      str = Targ_Print("%.20e", tvalue);
00397      strbase = Remove_Trailing_Zero_Fraction(str);
00398      /* Undo the 'e'->'d' conversion */
00399      if ((str = strchr(strbase, 'd')) != NULL)
00400        *str = 'e';
00401      newstr = (char *)malloc(sizeof(char)*1000); //((strlen(strbase)+1)*2+15));
00402      sprintf(newstr, "[%s, %s]", strbase, strbase);
00403      Append_Token_String(tokens, newstr);
00404      break;
00405    }
00406 
00407 #endif
00408    default:
00409       /* Only expression nodes should be handled here */
00410       ErrMsg (EC_Invalid_Case, "TCON2C_translate", __LINE__);
00411       Append_Token_String(tokens, "/*quad_constant*/");
00412       break;
00413    } /* switch */
00414 } /* TCON2C_translate */