1 /*
   2  * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 package build.tools.projectcreator;
  26 
  27 import java.util.Enumeration;
  28 import java.util.Hashtable;
  29 import java.util.Vector;
  30 
  31 class BuildConfig {
  32     @SuppressWarnings("rawtypes")
  33     Hashtable vars;
  34     Vector<String> basicNames, basicPaths;
  35     String[] context;
  36 
  37     static CompilerInterface ci;
  38     static CompilerInterface getCI() {
  39         if (ci == null) {
  40             String comp = (String)getField(null, "CompilerVersion");
  41             try {
  42                 ci = (CompilerInterface)Class.forName("build.tools.projectcreator.CompilerInterface" + comp).newInstance();
  43             } catch (Exception cnfe) {
  44                 System.err.println("Cannot find support for compiler " + comp);
  45                 throw new RuntimeException(cnfe.toString());
  46             }
  47         }
  48         return ci;
  49     }
  50 
  51     @SuppressWarnings("rawtypes")
  52     protected void initNames(String flavour, String build, String outDll) {
  53         if (vars == null) vars = new Hashtable();
  54 
  55         String flavourBuild =  flavour + "_" + build;
  56         String platformName = getFieldString(null, "PlatformName");
  57         System.out.println();
  58         System.out.println(flavourBuild);
  59 
  60         put("Name", getCI().makeCfgName(flavourBuild, platformName));
  61         put("Flavour", flavour);
  62         put("Build", build);
  63         put("PlatformName", platformName);
  64 
  65         // ones mentioned above were needed to expand format
  66         String buildBase = expandFormat(getFieldString(null, "BuildBase"));
  67         String sourceBase = getFieldString(null, "SourceBase");
  68         String buildSpace = getFieldString(null, "BuildSpace");
  69         String outDir = buildBase;
  70         String jdkTargetRoot = getFieldString(null, "JdkTargetRoot");
  71         String makeBinary = getFieldString(null, "MakeBinary");
  72         String makeOutput = expandFormat(getFieldString(null, "MakeOutput"));
  73 
  74         put("Id", flavourBuild);
  75         put("OutputDir", outDir);
  76         put("SourceBase", sourceBase);
  77         put("BuildBase", buildBase);
  78         put("BuildSpace", buildSpace);
  79         put("OutputDll", outDir + Util.sep + outDll);
  80         put("JdkTargetRoot", jdkTargetRoot);
  81         put("MakeBinary", makeBinary);
  82         put("MakeOutput", makeOutput);
  83 
  84         context = new String [] {flavourBuild, flavour, build, null};
  85     }
  86 
  87     protected void init(Vector<String> includes, Vector<String> defines) {
  88         initDefaultDefines(defines);
  89         initDefaultCompilerFlags(includes);
  90         initDefaultLinkerFlags();
  91         //handleDB();
  92     }
  93 
  94 
  95     protected void initDefaultCompilerFlags(Vector<String> includes) {
  96         Vector compilerFlags = new Vector();
  97 
  98         compilerFlags.addAll(getCI().getBaseCompilerFlags(getV("Define"),
  99                                                           includes,
 100                                                           get("OutputDir")));
 101 
 102         put("CompilerFlags", compilerFlags);
 103     }
 104 
 105     protected void initDefaultLinkerFlags() {
 106         Vector linkerFlags = new Vector();
 107 
 108         linkerFlags.addAll(getCI().getBaseLinkerFlags( get("OutputDir"), get("OutputDll"), get("PlatformName")));
 109 
 110         put("LinkerFlags", linkerFlags);
 111     }
 112 
 113     public boolean matchesIgnoredPath(String path) {
 114         Vector<String> rv = new Vector<String>();
 115         collectRelevantVectors(rv, "IgnorePath");
 116         for (String pathPart : rv) {
 117             if (path.contains(pathPart))  {
 118                 return true;
 119             }
 120         }
 121         return false;
 122     }
 123 
 124     public boolean matchesHidePath(String path) {
 125         Vector<String> rv = new Vector<String>();
 126         collectRelevantVectors(rv, "HidePath");
 127         for (String pathPart : rv) {
 128             if (path.contains(Util.normalize(pathPart)))  {
 129                 return true;
 130             }
 131         }
 132         return false;
 133     }
 134 
 135    public Vector<String> matchesAdditionalGeneratedPath(String fullPath) {
 136         Vector<String> rv = new Vector<String>();
 137         Hashtable<String, String> v = (Hashtable<String, String>)BuildConfig.getField(this.toString(), "AdditionalGeneratedFile");
 138         if (v != null) {
 139             for (Enumeration<String> e=v.keys(); e.hasMoreElements(); ) {
 140                 String key = e.nextElement();
 141                 String val = v.get(key);
 142 
 143                 if (fullPath.endsWith(expandFormat(key))) {
 144                     rv.add(expandFormat(val));
 145                 }
 146             }
 147         }
 148         return rv;
 149     }
 150 
 151     // Returns true if the specified path refers to a relative alternate
 152     // source file. RelativeAltSrcInclude is usually "src\closed".
 153     public static boolean matchesRelativeAltSrcInclude(String path) {
 154         String relativeAltSrcInclude =
 155             getFieldString(null, "RelativeAltSrcInclude");
 156         Vector<String> v = getFieldVector(null, "AltRelativeInclude");
 157         if (v != null) {
 158             for (String pathPart : v) {
 159                 if (path.contains(relativeAltSrcInclude + Util.sep + pathPart))  {
 160                     return true;
 161                 }
 162             }
 163             }
 164         return false;
 165     }
 166 
 167     // Returns the relative alternate source file for the specified path.
 168     // Null is returned if the specified path does not have a matching
 169     // alternate source file.
 170     public static String getMatchingRelativeAltSrcFile(String path) {
 171         Vector<String> v = getFieldVector(null, "RelativeAltSrcFileList");
 172         if (v == null) {
 173             return null;
 174         }
 175         for (String pathPart : v) {
 176             if (path.endsWith(pathPart)) {
 177                 String relativeAltSrcInclude =
 178                     getFieldString(null, "RelativeAltSrcInclude");
 179                 return relativeAltSrcInclude + Util.sep + pathPart;
 180             }
 181         }
 182         return null;
 183     }
 184 
 185     // Returns true if the specified path has a matching alternate
 186     // source file.
 187     public static boolean matchesRelativeAltSrcFile(String path) {
 188         return getMatchingRelativeAltSrcFile(path) != null;
 189     }
 190 
 191     // Track the specified alternate source file. The source file is
 192     // tracked without the leading .*<sep><RelativeAltSrcFileList><sep>
 193     // part to make matching regular source files easier.
 194     public static void trackRelativeAltSrcFile(String path) {
 195         String pattern = getFieldString(null, "RelativeAltSrcInclude") +
 196             Util.sep;
 197         int altSrcInd = path.indexOf(pattern);
 198         if (altSrcInd == -1) {
 199             // not an AltSrc path
 200             return;
 201         }
 202 
 203         altSrcInd += pattern.length();
 204         if (altSrcInd >= path.length()) {
 205             // not a valid AltSrc path
 206             return;
 207         }
 208 
 209         String altSrcFile = path.substring(altSrcInd);
 210         Vector v = getFieldVector(null, "RelativeAltSrcFileList");
 211         if (v == null || !v.contains(altSrcFile)) {
 212             addFieldVector(null, "RelativeAltSrcFileList", altSrcFile);
 213         }
 214     }
 215 
 216     void addTo(Hashtable ht, String key, String value) {
 217         ht.put(expandFormat(key), expandFormat(value));
 218     }
 219 
 220     void initDefaultDefines(Vector defines) {
 221         Vector sysDefines = new Vector();
 222         sysDefines.add("WIN32");
 223         sysDefines.add("_WINDOWS");
 224         sysDefines.add("HOTSPOT_BUILD_USER=\\\""+System.getProperty("user.name")+"\\\"");
 225         sysDefines.add("HOTSPOT_BUILD_TARGET=\\\""+get("Build")+"\\\"");
 226         sysDefines.add("INCLUDE_TRACE=1");
 227         sysDefines.add("_JNI_IMPLEMENTATION_");
 228         if (vars.get("PlatformName").equals("Win32")) {
 229             sysDefines.add("HOTSPOT_LIB_ARCH=\\\"i386\\\"");
 230         } else {
 231             sysDefines.add("HOTSPOT_LIB_ARCH=\\\"amd64\\\"");
 232         }
 233         sysDefines.add("DEBUG_LEVEL=\\\"" + get("Build")+"\\\"");
 234         sysDefines.addAll(defines);
 235 
 236         put("Define", sysDefines);
 237     }
 238 
 239     String get(String key) {
 240         return (String)vars.get(key);
 241     }
 242 
 243     Vector getV(String key) {
 244         return (Vector)vars.get(key);
 245     }
 246 
 247     Object getO(String key) {
 248         return vars.get(key);
 249     }
 250 
 251     Hashtable getH(String key) {
 252         return (Hashtable)vars.get(key);
 253     }
 254 
 255     Object getFieldInContext(String field) {
 256         for (int i=0; i<context.length; i++) {
 257             Object rv = getField(context[i], field);
 258             if (rv != null) {
 259                 return rv;
 260             }
 261         }
 262         return null;
 263     }
 264 
 265     Object lookupHashFieldInContext(String field, String key) {
 266         for (int i=0; i<context.length; i++) {
 267             Hashtable ht = (Hashtable)getField(context[i], field);
 268             if (ht != null) {
 269                 Object rv = ht.get(key);
 270                 if (rv != null) {
 271                     return rv;
 272                 }
 273             }
 274         }
 275         return null;
 276     }
 277 
 278     void put(String key, String value) {
 279         vars.put(key, value);
 280     }
 281 
 282     void put(String key, Vector vvalue) {
 283         vars.put(key, vvalue);
 284     }
 285 
 286     void add(String key, Vector vvalue) {
 287         getV(key).addAll(vvalue);
 288     }
 289 
 290     String flavour() {
 291         return get("Flavour");
 292     }
 293 
 294     String build() {
 295         return get("Build");
 296     }
 297 
 298     Object getSpecificField(String field) {
 299         return getField(get("Id"), field);
 300     }
 301 
 302     void putSpecificField(String field, Object value) {
 303         putField(get("Id"), field, value);
 304     }
 305 
 306     void collectRelevantVectors(Vector rv, String field) {
 307         for (String ctx : context) {
 308             Vector<String> v = getFieldVector(ctx, field);
 309             if (v != null) {
 310                 for (String val : v) {
 311                     rv.add(expandFormat(val).replace('/', '\\'));
 312                 }
 313             }
 314         }
 315     }
 316 
 317     void collectRelevantHashes(Hashtable rv, String field) {
 318         for (String ctx : context) {
 319             Hashtable v = (Hashtable)getField(ctx, field);
 320             if (v != null) {
 321                 for (Enumeration e=v.keys(); e.hasMoreElements(); ) {
 322                     String key = (String)e.nextElement();
 323                     String val =  (String)v.get(key);
 324                     addTo(rv, key, val);
 325                 }
 326             }
 327         }
 328     }
 329 
 330 
 331     Vector getDefines() {
 332         Vector rv = new Vector();
 333         collectRelevantVectors(rv, "Define");
 334         return rv;
 335     }
 336 
 337     Vector getIncludes() {
 338         Vector rv = new Vector();
 339         collectRelevantVectors(rv, "AbsoluteInclude");
 340         rv.addAll(getSourceIncludes());
 341         return rv;
 342     }
 343 
 344     private Vector getSourceIncludes() {
 345         Vector<String> rv = new Vector<String>();
 346         String sourceBase = getFieldString(null, "SourceBase");
 347 
 348         // add relative alternate source include values:
 349         String relativeAltSrcInclude =
 350             getFieldString(null, "RelativeAltSrcInclude");
 351         Vector<String> asri = new Vector<String>();
 352         collectRelevantVectors(asri, "AltRelativeInclude");
 353         for (String f : asri) {
 354             rv.add(sourceBase + Util.sep + relativeAltSrcInclude +
 355                    Util.sep + f);
 356         }
 357 
 358         Vector<String> ri = new Vector<String>();
 359         collectRelevantVectors(ri, "RelativeInclude");
 360         for (String f : ri) {
 361             rv.add(sourceBase + Util.sep + f);
 362         }
 363         return rv;
 364     }
 365 
 366     static Hashtable cfgData = new Hashtable();
 367     static Hashtable globalData = new Hashtable();
 368 
 369     static boolean appliesToTieredBuild(String cfg) {
 370         return (cfg != null &&
 371                 cfg.startsWith("server"));
 372     }
 373 
 374     // Filters out the IgnoreFile and IgnorePaths since they are
 375     // handled specially for tiered builds.
 376     static boolean appliesToTieredBuild(String cfg, String key) {
 377         return (appliesToTieredBuild(cfg))&& (key != null && !key.startsWith("Ignore"));
 378     }
 379 
 380     static String getTieredBuildCfg(String cfg) {
 381         assert appliesToTieredBuild(cfg) : "illegal configuration " + cfg;
 382         return "server";
 383     }
 384 
 385     static Object getField(String cfg, String field) {
 386         if (cfg == null) {
 387             return globalData.get(field);
 388         }
 389 
 390         Hashtable ht =  (Hashtable)cfgData.get(cfg);
 391         return ht == null ? null : ht.get(field);
 392     }
 393 
 394     static String getFieldString(String cfg, String field) {
 395         return (String)getField(cfg, field);
 396     }
 397 
 398     static Vector getFieldVector(String cfg, String field) {
 399         return (Vector)getField(cfg, field);
 400     }
 401 
 402     static void putField(String cfg, String field, Object value) {
 403         putFieldImpl(cfg, field, value);
 404         if (appliesToTieredBuild(cfg, field)) {
 405             putFieldImpl(getTieredBuildCfg(cfg), field, value);
 406         }
 407     }
 408 
 409     private static void putFieldImpl(String cfg, String field, Object value) {
 410         if (cfg == null) {
 411             globalData.put(field, value);
 412             return;
 413         }
 414 
 415         Hashtable ht = (Hashtable)cfgData.get(cfg);
 416         if (ht == null) {
 417             ht = new Hashtable();
 418             cfgData.put(cfg, ht);
 419         }
 420 
 421         ht.put(field, value);
 422     }
 423 
 424     static Object getFieldHash(String cfg, String field, String name) {
 425         Hashtable ht = (Hashtable)getField(cfg, field);
 426 
 427         return ht == null ? null : ht.get(name);
 428     }
 429 
 430     static void putFieldHash(String cfg, String field, String name, Object val) {
 431         putFieldHashImpl(cfg, field, name, val);
 432         if (appliesToTieredBuild(cfg, field)) {
 433             putFieldHashImpl(getTieredBuildCfg(cfg), field, name, val);
 434         }
 435     }
 436 
 437     private static void putFieldHashImpl(String cfg, String field, String name, Object val) {
 438         Hashtable ht = (Hashtable)getField(cfg, field);
 439 
 440         if (ht == null) {
 441             ht = new Hashtable();
 442             putFieldImpl(cfg, field, ht);
 443         }
 444 
 445         ht.put(name, val);
 446     }
 447 
 448     static void addFieldVector(String cfg, String field, String element) {
 449         addFieldVectorImpl(cfg, field, element);
 450         if (appliesToTieredBuild(cfg, field)) {
 451             addFieldVectorImpl(getTieredBuildCfg(cfg), field, element);
 452         }
 453     }
 454 
 455     private static void addFieldVectorImpl(String cfg, String field, String element) {
 456         Vector v = (Vector)getField(cfg, field);
 457 
 458         if (v == null) {
 459             v = new Vector();
 460             putFieldImpl(cfg, field, v);
 461         }
 462 
 463         v.add(element);
 464     }
 465 
 466     String expandFormat(String format) {
 467         if (format == null) {
 468             return null;
 469         }
 470 
 471         if (format.indexOf('%') == -1) {
 472             return format;
 473         }
 474 
 475         StringBuffer sb = new StringBuffer();
 476         int len = format.length();
 477         for (int i=0; i<len; i++) {
 478             char ch = format.charAt(i);
 479             if (ch == '%') {
 480                 char ch1 = format.charAt(i+1);
 481                 switch (ch1) {
 482                 case '%':
 483                     sb.append(ch1);
 484                     break;
 485                 case 'b':
 486                     sb.append(build());
 487                     break;
 488                 case 'f':
 489                     sb.append(flavour());
 490                     break;
 491                 default:
 492                     sb.append(ch);
 493                     sb.append(ch1);
 494                 }
 495                 i++;
 496             } else {
 497                 sb.append(ch);
 498             }
 499         }
 500 
 501         return sb.toString();
 502     }
 503 }
 504 
 505 abstract class GenericDebugConfig extends BuildConfig {
 506     abstract String getOptFlag();
 507 
 508     protected void init(Vector includes, Vector defines) {
 509         defines.add("_DEBUG");
 510         defines.add("ASSERT");
 511 
 512         super.init(includes, defines);
 513 
 514         getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag(), get("PlatformName")));
 515         getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags());
 516    }
 517 }
 518 
 519 abstract class GenericDebugNonKernelConfig extends GenericDebugConfig {
 520     protected void init(Vector includes, Vector defines) {
 521         super.init(includes, defines);
 522         if (get("PlatformName").equals("Win32")) {
 523             getCI().getAdditionalNonKernelLinkerFlags(getV("LinkerFlags"));
 524         }
 525    }
 526 }
 527 
 528 class C1DebugConfig extends GenericDebugNonKernelConfig {
 529     String getOptFlag() {
 530         return getCI().getNoOptFlag();
 531     }
 532 
 533     C1DebugConfig() {
 534         initNames("client", "debug", "jvm.dll");
 535         init(getIncludes(), getDefines());
 536     }
 537 }
 538 
 539 class C1FastDebugConfig extends GenericDebugNonKernelConfig {
 540     String getOptFlag() {
 541         return getCI().getOptFlag();
 542     }
 543 
 544     C1FastDebugConfig() {
 545         initNames("client", "fastdebug", "jvm.dll");
 546         init(getIncludes(), getDefines());
 547     }
 548 }
 549 
 550 class TieredDebugConfig extends GenericDebugNonKernelConfig {
 551     String getOptFlag() {
 552         return getCI().getNoOptFlag();
 553     }
 554 
 555     TieredDebugConfig() {
 556         initNames("server", "debug", "jvm.dll");
 557         init(getIncludes(), getDefines());
 558     }
 559 }
 560 
 561 class TieredFastDebugConfig extends GenericDebugNonKernelConfig {
 562     String getOptFlag() {
 563         return getCI().getOptFlag();
 564     }
 565 
 566     TieredFastDebugConfig() {
 567         initNames("server", "fastdebug", "jvm.dll");
 568         init(getIncludes(), getDefines());
 569     }
 570 }
 571 
 572 abstract class ProductConfig extends BuildConfig {
 573     protected void init(Vector includes, Vector defines) {
 574         defines.add("NDEBUG");
 575         defines.add("PRODUCT");
 576 
 577         super.init(includes, defines);
 578 
 579         getV("CompilerFlags").addAll(getCI().getProductCompilerFlags());
 580         getV("LinkerFlags").addAll(getCI().getProductLinkerFlags());
 581     }
 582 }
 583 
 584 class C1ProductConfig extends ProductConfig {
 585     C1ProductConfig() {
 586         initNames("client", "product", "jvm.dll");
 587         init(getIncludes(), getDefines());
 588     }
 589 }
 590 
 591 class TieredProductConfig extends ProductConfig {
 592     TieredProductConfig() {
 593         initNames("server", "product", "jvm.dll");
 594         init(getIncludes(), getDefines());
 595     }
 596 }
 597 
 598 
 599 abstract class CompilerInterface {
 600     abstract Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir);
 601     abstract Vector getBaseLinkerFlags(String outDir, String outDll, String platformName);
 602     abstract Vector getDebugCompilerFlags(String opt, String platformName);
 603     abstract Vector getDebugLinkerFlags();
 604     abstract void   getAdditionalNonKernelLinkerFlags(Vector rv);
 605     abstract Vector getProductCompilerFlags();
 606     abstract Vector getProductLinkerFlags();
 607     abstract String getOptFlag();
 608     abstract String getNoOptFlag();
 609     abstract String makeCfgName(String flavourBuild, String platformName);
 610 
 611     void addAttr(Vector receiver, String attr, String value) {
 612         receiver.add(attr); receiver.add(value);
 613     }
 614     void extAttr(Vector receiver, String attr, String value) {
 615         int attr_pos=receiver.indexOf(attr) ;
 616         if ( attr_pos == -1) {
 617           // If attr IS NOT present in the Vector - add it
 618           receiver.add(attr); receiver.add(value);
 619         } else {
 620           // If attr IS present in the Vector - append value to it
 621           receiver.set(attr_pos+1,receiver.get(attr_pos+1)+value);
 622         }
 623     }
 624 }