tools/Gcc_cmdline.java

   1
   2 package org.de.metux.unitool.tools;
   3
   4 import org.de.metux.unitool.base.EUnhandledCompilerFlag;
   5 import org.de.metux.util.HTMLEntities;
   6 import org.de.metux.util.ShellEscape;
   7 import org.de.metux.util.PathNormalizer;
   8 import org.de.metux.util.FileOps;
   9 import org.de.metux.util.StrUtil;
  10 import org.de.metux.unitool.base.CCompilerParam;
  11
  12 public class Gcc_cmdline
  13 {
  14     String cmdline = "";
  15     PathNormalizer normalizer;
  16     String warning_flags = "";
  17
  18     boolean create_pic    = false;
  19     boolean create_shared = false;
  20
  21     public Gcc_cmdline(String s)
  22     {
  23         cmdline = s;
  24     }
  25
  26     public void setNormalizer(PathNormalizer n)
  27     {
  28         normalizer = n;
  29     }
  30
  31     public String toString()
  32     {
  33         return cmdline+
  34             warning_flags+
  35             (create_pic    ? " -fPIC -DPIC " : "")+
  36             (create_shared ? " -shared " : "");
  37     }
  38
  39     public void libpath(String p)
  40     {
  41         if (!StrUtil.isEmpty(p))
  42             cmdline += " -L"+normalizer.dec_sysroot(p);
  43     }
  44
  45     public void libpath(String[] par)
  46     {
  47         if (par!=null)
  48             for (int x=0; x<par.length; x++)
  49                 libpath(par[x]);
  50     }
  51
  52     public void addDefine(String par)
  53     {
  54         if (!StrUtil.isEmpty(par))
  55         {
  56             par = HTMLEntities.decode(par);
  57             cmdline += " "+ShellEscape.quoting("-D"+
  58 // FIXME !!! just an ugly test to do this twice
  59                 HTMLEntities.decode(HTMLEntities.decode(par)))+" ";
  60         }
  61
  62     }
  63
  64     public void addDefine(String[] par)
  65     {
  66         if (!StrUtil.isEmpty(par))
  67             for (int x=0; x<par.length; x++)
  68                 addDefine(par[x]);
  69     }
  70
  71     public void addIncludeFile(String[] par)
  72     {
  73         if (par!=null)
  74             for (int x=0; x<par.length; x++)
  75                 addIncludeFile(par[x]);
  76     }
  77
  78     public void addIncludeFile(String par)
  79     {
  80         if (!StrUtil.isEmpty(par))
  81             cmdline += " --include \""+par+"\"";
  82     }
  83
  84     public void addIncludePath(String[] par)
  85     {
  86         if (par!=null)
  87             for (int x=0; x<par.length; x++)
  88                 addIncludePath(par[x]);
  89     }
  90
  91     public void addIncludePath(String par)
  92     {
  93         if (!StrUtil.isEmpty(par))
  94             cmdline += " -I"+par;
  95     }
  96
  97     public void output_filename(String fn)
  98     {
  99         if (!StrUtil.isEmpty(fn))
 100         {
 101             FileOps.mkdir(PathNormalizer.dirname(fn));
 102             cmdline += " -o "+fn;
 103         }
 104     }
 105
 106     public void dynlink(String[] par)
 107     {
 108         if (!StrUtil.isEmpty(par))
 109             for (int x=0; x<par.length; x++)
 110                 if (par[x].length()>0)
 111                     cmdline += " -l"+par[x];
 112     }
 113
 114     public void objlink(String[] par)
 115     {
 116         if (!StrUtil.isEmpty(par))
 117             for (int x=0; x<par.length; x++)
 118                 if (par[x].length()>0)
 119                     cmdline += " "+par[x];
 120     }
 121
 122     public void linker_flag(String flag)
 123     {
 124         if (flag.equals("no-undefined"))
 125             cmdline += " -no-undefined";
 126         else
 127             throw new RuntimeException("unhandled flag: "+flag);
 128     }
 129
 130     public void warning_flag(String flag[])
 131     {
 132         if (flag!=null)
 133             for (int x=0; x<flag.length; x++)
 134                 warning_flag(flag[x]);
 135     }
 136
 137     public void warning_flag(String flag)
 138     {
 139         if ((flag==null)||(flag.length()==0))
 140             return;
 141
 142         if (flag.equals(CCompilerParam.flag_warn_pointer_arith))
 143             warning_flags += " -Wpointer-arith";
 144         else if (flag.equals(CCompilerParam.flag_warn_strict_prototypes))
 145             warning_flags += " -Wstrict-prototypes";
 146         else if (flag.equals(CCompilerParam.flag_warn_missing_prototypes))
 147             warning_flags += " -Wmissing-prototypes";
 148         else if (flag.equals(CCompilerParam.flag_warn_missing_declarations))
 149             warning_flags += " -Wmissing-declarations";
 150         else if (flag.equals(CCompilerParam.flag_warn_nested_externs))
 151             warning_flags += " -Wnested-externs";
 152         else if (flag.equals(CCompilerParam.flag_warn_all))
 153             warning_flags += " -Wall";
 154         else if (flag.equals(CCompilerParam.flag_warn_unused))
 155             warning_flags += " -Wunused";
 156         else if (flag.equals(CCompilerParam.flag_warn_no_unused))
 157             warning_flags += " -Wno-unused";
 158         else if (flag.equals(CCompilerParam.flag_warn_no_format))
 159             warning_flags += " -Wno-format";
 160         else if (flag.equals(CCompilerParam.flag_warn_error))
 161             warning_flags += " -Werror";
 162         else if (flag.equals(CCompilerParam.flag_warn_inline))
 163             warning_flags += " -Winline";
 164         else if (flag.equals(CCompilerParam.flag_warn_cast_align))
 165             warning_flags += " -Wcast-align";
 166         else if (flag.equals(CCompilerParam.flag_warn_write_strings))
 167             warning_flags += " -Wwrite-strings";
 168         else if (flag.equals(CCompilerParam.flag_warn_declaration_after_statement))
 169             warning_flags += " -Wdeclaration-after-statement";
 170         else
 171             throw new RuntimeException("unsupported warning flag: "+flag);
 172     }
 173
 174     public void compiler_flag(String flag)
 175         throws EUnhandledCompilerFlag
 176     {
 177         if (flag.equals(""))
 178             ;
 179         else if (flag.equals("pic"))
 180             create_pic = true;
 181         else if (flag.equals(CCompilerParam.flag_mkdepend_dummytargets))
 182             cmdline += " -MP";
 183         else if (flag.equals(CCompilerParam.flag_mkdepend_default))
 184             cmdline += " -MD";
 185         else
 186             throw new EUnhandledCompilerFlag(flag);
 187     }
 188
 189     public void linker_flag(String[] par)
 190     {
 191         if (par!=null)
 192             for (int x=0; x<par.length; x++)
 193                 linker_flag(par[x]);
 194     }
 195
 196     public void compiler_flag(String[] par)
 197         throws EUnhandledCompilerFlag
 198     {
 199         if (par!=null)
 200             for (int x=0; x<par.length; x++)
 201                 compiler_flag(par[x]);
 202     }
 203
 204     public void staticlink(String[] par)
 205     {
 206         if (par!=null)
 207             for (int x=0; x<par.length; x++)
 208                 staticlink(par[x]);
 209     }
 210
 211     public void staticlink(String filename)
 212     {
 213         if (!StrUtil.isEmpty(filename))
 214             cmdline += " -Wl,--whole-archive "+filename;
 215     }
 216
 217     /* add an --rpath option */
 218     public void rpath(String rpath)
 219     {
 220         if (!StrUtil.isEmpty(rpath))
 221             cmdline += " -Wl,--rpath -Wl,"+rpath;
 222     }
 223
 224     public void rpath(String[] par)
 225     {
 226         if (!StrUtil.isEmpty(par))
 227             for (int x=0; x<par.length; x++)
 228                 rpath(par[x]);
 229     }
 230
 231     public void verbatims(String[] par)
 232     {
 233         if (!StrUtil.isEmpty(par))
 234             for (int x=0; x<par.length; x++)
 235                 if (par[x].length()>0)
 236                 {
 237                     System.err.println("GCC-backend: adding verbatim: "+par[x]);
 238                     cmdline += " \""+par[x]+"\"";
 239                 }
 240     }
 241
 242     public void srcs(String[] par)
 243     {
 244         if (!StrUtil.isEmpty(par))
 245             for (int x=0; x<par.length; x++)
 246                 if (par[x].length()>0)
 247                     cmdline += " "+par[x];
 248     }
 249
 250     public void mk_depend_output(String par)
 251     {
 252         if (!StrUtil.isEmpty(par))
 253             cmdline += " -MF "+par;
 254     }
 255
 256     public void mk_depend_target(String par)
 257     {
 258         if (!StrUtil.isEmpty(par))
 259             cmdline += " -MT "+par;
 260     }
 261
 262     public void shared(boolean sh)
 263     {
 264         create_shared = sh;
 265     }
 266
 267     public void setPIC(boolean flag)
 268     {
 269         create_pic = flag;
 270     }
 271
 272     public void exportSymbols(String re[])
 273     {
 274         if (re!=null)
 275             for (int x=0; x<re.length; x++)
 276                 if ((re[x]!=null) && (re[x].length()!=0))
 277                     System.err.println("WARN: -export-symbols not implemented yet");
 278 //                  cmdline += " --export-symbols \""+re[x]+"\"";
 279     }
 280
 281     public void exportSymbolsRegex(String re[])
 282     {
 283         if (re!=null)
 284             for (int x=0; x<re.length; x++)
 285                 if ((re[x]!=null) && (re[x].length()!=0))
 286                     System.err.println("WARN: -export-symbols-regex not implemented yet");
 287 //                  cmdline += " --export-symbols-regex \""+re[x]+"\"";
 288     }
 289 }