1 /*

     2  * Copyright (c) 2005, 2009, 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 import java.util.*;

    26 import java.io.File;

    27 

    28 class BuildConfig {

    29     Hashtable vars;

    30     Vector basicNames, basicPaths;

    31     String[] context;

    32 

    33     static CompilerInterface ci;

    34     static CompilerInterface getCI() {

    35         if (ci == null) {

    36             String comp = (String)getField(null, "CompilerVersion");

    37             try {

    38                 ci = (CompilerInterface)Class.forName("CompilerInterface" + comp).newInstance();

    39             } catch (Exception cnfe) {

    40                 System.err.println("Cannot find support for compiler " + comp);

    41                 throw new RuntimeException(cnfe.toString());

    42             }

    43         }

    44         return ci;

    45     }

    46 

    47     protected void initNames(String flavour, String build, String outDll) {

    48         if (vars == null) vars = new Hashtable();

    49 

    50         String flavourBuild =  flavour + "_" + build;

    51         put("Name", getCI().makeCfgName(flavourBuild));

    52         put("Flavour", flavour);

    53         put("Build", build);

    54 

    55         // ones mentioned above were needed to expand format

    56         String buildBase = expandFormat(getFieldString(null, "BuildBase"));

    57         String jdkDir =  getFieldString(null, "JdkTargetRoot");

    58         String sourceBase = getFieldString(null, "SourceBase");

    59         String outDir = buildBase;

    60 

    61         put("Id", flavourBuild);

    62         put("OutputDir", outDir);

    63         put("SourceBase", sourceBase);

    64         put("BuildBase", buildBase);

    65         put("OutputDll", jdkDir + Util.sep + outDll);

    66 

    67         context = new String [] {flavourBuild, flavour, build, null};

    68     }

    69 

    70     protected void init(Vector includes, Vector defines) {

    71         initDefaultDefines(defines);

    72         initDefaultCompilerFlags(includes);

    73         initDefaultLinkerFlags();

    74         handleDB((String)getFieldInContext("IncludeDB"));

    75     }

    76 

    77 

    78     protected void initDefaultCompilerFlags(Vector includes) {

    79         Vector compilerFlags = new Vector();

    80 

    81         compilerFlags.addAll(getCI().getBaseCompilerFlags(getV("Define"),

    82                                                           includes,

    83                                                           get("OutputDir")));

    84 

    85         put("CompilerFlags", compilerFlags);

    86     }

    87 

    88     protected void initDefaultLinkerFlags() {

    89         Vector linkerFlags = new Vector();

    90 

    91         linkerFlags.addAll(getCI().getBaseLinkerFlags( get("OutputDir"), get("OutputDll")));

    92 

    93         put("LinkerFlags", linkerFlags);

    94     }

    95 

    96     DirectoryTree getSourceTree(String sourceBase, String startAt) {

    97         DirectoryTree tree = new DirectoryTree();

    98 

    99         tree.addSubdirToIgnore("Codemgr_wsdata");

   100         tree.addSubdirToIgnore("deleted_files");

   101         tree.addSubdirToIgnore("SCCS");

   102         tree.setVerbose(true);

   103         if (startAt != null) {

   104             tree.readDirectory(sourceBase + File.separator + startAt);

   105         } else {

   106             tree.readDirectory(sourceBase);

   107         }

   108 

   109         return tree;

   110     }

   111 

   112 

   113     Vector getPreferredPaths(Database currentDB) {

   114         Vector preferredPaths = new Vector();

   115         // In the case of multiple files with the same name in

   116         // different subdirectories, prefer the versions specified in

   117         // the platform file as the "os_family" and "arch" macros.

   118         for (Iterator iter = currentDB.getMacros(); iter.hasNext(); ) {

   119             Macro macro = (Macro) iter.next();

   120             if (macro.name.equals("os_family") ||

   121                 macro.name.equals("arch")) {

   122                 preferredPaths.add(macro.contents);

   123             }

   124         }

   125         // Also prefer "opto" over "adlc" for adlcVMDeps.hpp

   126         preferredPaths.add("opto");

   127 

   128         return preferredPaths;

   129     }

   130 

   131 

   132     void handleDB(String dbFile) {

   133         WinGammaPlatform platform = (WinGammaPlatform)getField(null, "PlatformObject");

   134         Database db = new Database(platform, platform.defaultGrandIncludeThreshold());

   135 

   136         try {

   137             File incls = new File(get("OutputDir")+Util.sep+"incls");

   138             FileName oldInclTempl = platform.getInclFileTemplate();

   139             FileName oldGITempl = platform.getGIFileTemplate();

   140             FileName oldGDTempl = platform.getGDFileTemplate();

   141 

   142             platform.setInclFileTemplate(new FileName(platform, incls.getPath()+Util.sep,

   143                                                       "_", "", ".incl", "", ""));

   144             platform.setGIFileTemplate(new FileName(platform, incls.getPath()+Util.sep,

   145                                                     "",  "_precompiled", ".incl", "", ""));

   146 

   147             incls.mkdirs();

   148 

   149             db.get(getFieldString(null, "Platform"), dbFile);

   150             db.compute();

   151 

   152             db.put();

   153 

   154             //platform.setInclFileTemplate(oldInclTempl);

   155             //platform.setGIFileTemplate(oldInclTempl);

   156         } catch (Exception e) {

   157             e.printStackTrace();

   158             throw new RuntimeException("cannot do db: "+e);

   159         }

   160 

   161         putSpecificField("AllFilesHash", computeAllFiles(platform, db));

   162     }

   163 

   164 

   165     void addAll(Iterator i, Hashtable hash,

   166                 WinGammaPlatform platform, DirectoryTree tree,

   167                 Vector preferredPaths, Vector filesNotFound, Vector filesDuplicate) {

   168         for (; i.hasNext(); ) {

   169             String fileName = (String) i.next();

   170             if (lookupHashFieldInContext("IgnoreFile", fileName) == null) {

   171                 String prefixedName = platform.envVarPrefixedFileName(fileName,

   172                                                                       0, /* ignored */

   173                                                                       tree,

   174                                                                       preferredPaths,

   175                                                                       filesNotFound,

   176                                                                       filesDuplicate);

   177                 if (prefixedName != null) {

   178                     addTo(hash, Util.normalize(prefixedName), fileName);

   179                 }

   180             }

   181         }

   182     }

   183 

   184     void addTo(Hashtable ht, String key, String value) {

   185         ht.put(expandFormat(key), expandFormat(value));

   186     }

   187 

   188     Hashtable computeAllFiles(WinGammaPlatform platform, Database db) {

   189         Hashtable rv = new Hashtable();

   190         DirectoryTree tree = getSourceTree(get("SourceBase"), getFieldString(null, "StartAt"));

   191         Vector preferredPaths = getPreferredPaths(db);

   192 

   193         // Hold errors until end

   194         Vector filesNotFound = new Vector();

   195         Vector filesDuplicate = new Vector();

   196 

   197 

   198         // find all files

   199         Vector dbFiles = new Vector();

   200         for (Iterator i=db.getAllFiles().iterator(); i.hasNext(); ) {

   201             FileList fl = (FileList) i.next();

   202             dbFiles.add(fl.getName());

   203         }

   204         addAll(dbFiles.iterator(), rv,

   205                platform, tree,

   206                preferredPaths, filesNotFound, filesDuplicate);

   207 

   208         Vector addFiles = new Vector();

   209         collectRelevantVectors(addFiles, "AdditionalFile");

   210         addAll(addFiles.iterator(), rv,

   211                platform, tree,

   212                preferredPaths, filesNotFound, filesDuplicate);

   213 

   214         collectRelevantHashes(rv, "AdditionalGeneratedFile");

   215 

   216         if ((filesNotFound.size() != 0) ||

   217             (filesDuplicate.size() != 0)) {

   218             System.err.println("Error: some files were not found or " +

   219                                "appeared in multiple subdirectories of " +

   220                                "directory " + get("SourceBase") + " and could not " +

   221                                "be resolved with the os_family and arch " +

   222                                "macros in the platform file.");

   223             if (filesNotFound.size() != 0) {

   224                 System.err.println("Files not found:");

   225                 for (Iterator iter = filesNotFound.iterator();

   226                      iter.hasNext(); ) {

   227                     System.err.println("  " + (String) iter.next());

   228                 }

   229             }

   230             if (filesDuplicate.size() != 0) {

   231                 System.err.println("Duplicate files:");

   232                 for (Iterator iter = filesDuplicate.iterator();

   233                      iter.hasNext(); ) {

   234                     System.err.println("  " + (String) iter.next());

   235                 }

   236             }

   237             throw new RuntimeException();

   238         }

   239 

   240         return rv;

   241     }

   242 

   243     void initDefaultDefines(Vector defines) {

   244         Vector sysDefines = new Vector();

   245         sysDefines.add("WIN32");

   246         sysDefines.add("_WINDOWS");

   247         sysDefines.add("HOTSPOT_BUILD_USER="+System.getProperty("user.name"));

   248         sysDefines.add("HOTSPOT_BUILD_TARGET=\\\""+get("Build")+"\\\"");

   249         sysDefines.add("_JNI_IMPLEMENTATION_");

   250         sysDefines.add("HOTSPOT_LIB_ARCH=\\\"i386\\\"");

   251 

   252         sysDefines.addAll(defines);

   253 

   254         put("Define", sysDefines);

   255     }

   256 

   257     String get(String key) {

   258         return (String)vars.get(key);

   259     }

   260 

   261     Vector getV(String key) {

   262         return (Vector)vars.get(key);

   263     }

   264 

   265     Object getO(String key) {

   266         return vars.get(key);

   267     }

   268 

   269     Hashtable getH(String key) {

   270         return (Hashtable)vars.get(key);

   271     }

   272 

   273     Object getFieldInContext(String field) {

   274         for (int i=0; i<context.length; i++) {

   275             Object rv = getField(context[i], field);

   276             if (rv != null) {

   277                 return rv;

   278             }

   279         }

   280         return null;

   281     }

   282 

   283     Object lookupHashFieldInContext(String field, String key) {

   284         for (int i=0; i<context.length; i++) {

   285             Hashtable ht = (Hashtable)getField(context[i], field);

   286             if (ht != null) {

   287                 Object rv = ht.get(key);

   288                 if (rv != null) {

   289                     return rv;

   290                 }

   291             }

   292         }

   293         return null;

   294     }

   295 

   296     void put(String key, String value) {

   297         vars.put(key, value);

   298     }

   299 

   300     void put(String key, Vector vvalue) {

   301         vars.put(key, vvalue);

   302     }

   303 

   304     void add(String key, Vector vvalue) {

   305         getV(key).addAll(vvalue);

   306     }

   307 

   308     String flavour() {

   309         return get("Flavour");

   310     }

   311 

   312     String build() {

   313         return get("Build");

   314     }

   315 

   316     Object getSpecificField(String field) {

   317         return getField(get("Id"), field);

   318     }

   319 

   320     void putSpecificField(String field, Object value) {

   321         putField(get("Id"), field, value);

   322     }

   323 

   324     void collectRelevantVectors(Vector rv, String field) {

   325         for (int i = 0; i < context.length; i++) {

   326             Vector v = getFieldVector(context[i], field);

   327             if (v != null) {

   328                 for (Iterator j=v.iterator(); j.hasNext(); ) {

   329                     String val = (String)j.next();

   330                     rv.add(expandFormat(val));

   331                 }

   332             }

   333         }

   334     }

   335 

   336     void collectRelevantHashes(Hashtable rv, String field) {

   337         for (int i = 0; i < context.length; i++) {

   338             Hashtable v = (Hashtable)getField(context[i], field);

   339             if (v != null) {

   340                 for (Enumeration e=v.keys(); e.hasMoreElements(); ) {

   341                     String key = (String)e.nextElement();

   342                     String val =  (String)v.get(key);

   343                     addTo(rv, key, val);

   344                 }

   345             }

   346         }

   347     }

   348 

   349 

   350     Vector getDefines() {

   351         Vector rv = new Vector();

   352         collectRelevantVectors(rv, "Define");

   353         return rv;

   354     }

   355 

   356     Vector getIncludes() {

   357         Vector rv = new Vector();

   358 

   359         // for generated includes

   360         rv.add(get("OutputDir"));

   361 

   362         collectRelevantVectors(rv, "AbsoluteInclude");

   363 

   364         Vector ri = new Vector();

   365         String sourceBase = getFieldString(null, "SourceBase");

   366         collectRelevantVectors(ri, "RelativeInclude");

   367         for (Iterator i = ri.iterator(); i.hasNext(); ) {

   368             String f = (String)i.next();

   369             rv.add(sourceBase + Util.sep + f);

   370         }

   371 

   372         return rv;

   373     }

   374 

   375     static Hashtable cfgData = new Hashtable();

   376     static Hashtable globalData = new Hashtable();

   377 

   378     static boolean appliesToTieredBuild(String cfg) {

   379         return (cfg != null &&

   380                 (cfg.startsWith("compiler1") ||

   381                  cfg.startsWith("compiler2")));

   382     }

   383 

   384     // Filters out the IncludeDB statement, which is the only command-

   385     // line argument we explicitly specialize for the tiered build

   386     static boolean appliesToTieredBuild(String cfg, String key) {

   387         return (appliesToTieredBuild(cfg) &&

   388                 (key != null &&

   389                  !key.equals("IncludeDB")));

   390     }

   391 

   392     static String getTieredBuildCfg(String cfg) {

   393         assert appliesToTieredBuild(cfg) : "illegal configuration " + cfg;

   394         return "tiered" + cfg.substring(9);

   395     }

   396 

   397     static Object getField(String cfg, String field) {

   398         if (cfg == null) {

   399             return globalData.get(field);

   400         }

   401 

   402         Hashtable ht =  (Hashtable)cfgData.get(cfg);

   403         return ht == null ? null : ht.get(field);

   404     }

   405 

   406     static String getFieldString(String cfg, String field) {

   407         return (String)getField(cfg, field);

   408     }

   409 

   410     static Vector getFieldVector(String cfg, String field) {

   411         return (Vector)getField(cfg, field);

   412     }

   413 

   414     static void putField(String cfg, String field, Object value) {

   415         putFieldImpl(cfg, field, value);

   416         if (appliesToTieredBuild(cfg, field)) {

   417             putFieldImpl(getTieredBuildCfg(cfg), field, value);

   418         }

   419     }

   420 

   421     private static void putFieldImpl(String cfg, String field, Object value) {

   422         if (cfg == null) {

   423             globalData.put(field, value);

   424             return;

   425         }

   426 

   427         Hashtable ht = (Hashtable)cfgData.get(cfg);

   428         if (ht == null) {

   429             ht = new Hashtable();

   430             cfgData.put(cfg, ht);

   431         }

   432 

   433         ht.put(field, value);

   434     }

   435 

   436     static Object getFieldHash(String cfg, String field, String name) {

   437         Hashtable ht = (Hashtable)getField(cfg, field);

   438 

   439         return ht == null ? null : ht.get(name);

   440     }

   441 

   442     static void putFieldHash(String cfg, String field, String name, Object val) {

   443         putFieldHashImpl(cfg, field, name, val);

   444         if (appliesToTieredBuild(cfg)) {

   445             putFieldHashImpl(getTieredBuildCfg(cfg), field, name, val);

   446         }

   447     }

   448 

   449     private static void putFieldHashImpl(String cfg, String field, String name, Object val) {

   450         Hashtable ht = (Hashtable)getField(cfg, field);

   451 

   452         if (ht == null) {

   453             ht = new Hashtable();

   454             putFieldImpl(cfg, field, ht);

   455         }

   456 

   457         ht.put(name, val);

   458     }

   459 

   460     static void addFieldVector(String cfg, String field, String element) {

   461         addFieldVectorImpl(cfg, field, element);

   462         if (appliesToTieredBuild(cfg)) {

   463             addFieldVectorImpl(getTieredBuildCfg(cfg), field, element);

   464         }

   465     }

   466 

   467     private static void addFieldVectorImpl(String cfg, String field, String element) {

   468         Vector v = (Vector)getField(cfg, field);

   469 

   470         if (v == null) {

   471             v = new Vector();

   472             putFieldImpl(cfg, field, v);

   473         }

   474 

   475         v.add(element);

   476     }

   477 

   478     String expandFormat(String format) {

   479         if (format == null) {

   480             return null;

   481         }

   482 

   483         if (format.indexOf('%') == -1) {

   484             return format;

   485         }

   486 

   487         StringBuffer sb = new StringBuffer();

   488         int len = format.length();

   489         for (int i=0; i<len; i++) {

   490             char ch = format.charAt(i);

   491             if (ch == '%') {

   492                 char ch1 = format.charAt(i+1);

   493                 switch (ch1) {

   494                 case '%':

   495                     sb.append(ch1);

   496                     break;

   497                 case 'b':

   498                     sb.append(build());

   499                     break;

   500                 case 'f':

   501                     sb.append(flavour());

   502                     break;

   503                 default:

   504                     sb.append(ch);

   505                     sb.append(ch1);

   506                 }

   507                 i++;

   508             } else {

   509                 sb.append(ch);

   510             }

   511         }

   512 

   513         return sb.toString();

   514     }

   515 }

   516 

   517 abstract class GenericDebugConfig extends BuildConfig {

   518     abstract String getOptFlag();

   519 

   520     protected void init(Vector includes, Vector defines) {

   521         defines.add("_DEBUG");

   522         defines.add("ASSERT");

   523 

   524         super.init(includes, defines);

   525 

   526         getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag()));

   527         getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags());

   528    }

   529 }

   530 

   531 class C1DebugConfig extends GenericDebugConfig {

   532     String getOptFlag() {

   533         return getCI().getNoOptFlag();

   534     }

   535 

   536     C1DebugConfig() {

   537         initNames("compiler1", "debug", "fastdebug\\jre\\bin\\client\\jvm.dll");

   538         init(getIncludes(), getDefines());

   539     }

   540 }

   541 

   542 class C1FastDebugConfig extends GenericDebugConfig {

   543     String getOptFlag() {

   544         return getCI().getOptFlag();

   545     }

   546 

   547     C1FastDebugConfig() {

   548         initNames("compiler1", "fastdebug", "fastdebug\\jre\\bin\\client\\jvm.dll");

   549         init(getIncludes(), getDefines());

   550     }

   551 }

   552 

   553 class C2DebugConfig extends GenericDebugConfig {

   554     String getOptFlag() {

   555         return getCI().getNoOptFlag();

   556     }

   557 

   558     C2DebugConfig() {

   559         initNames("compiler2", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   560         init(getIncludes(), getDefines());

   561     }

   562 }

   563 

   564 class C2FastDebugConfig extends GenericDebugConfig {

   565     String getOptFlag() {

   566         return getCI().getOptFlag();

   567     }

   568 

   569     C2FastDebugConfig() {

   570         initNames("compiler2", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   571         init(getIncludes(), getDefines());

   572     }

   573 }

   574 

   575 class TieredDebugConfig extends GenericDebugConfig {

   576     String getOptFlag() {

   577         return getCI().getNoOptFlag();

   578     }

   579 

   580     TieredDebugConfig() {

   581         initNames("tiered", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   582         init(getIncludes(), getDefines());

   583     }

   584 }

   585 

   586 class TieredFastDebugConfig extends GenericDebugConfig {

   587     String getOptFlag() {

   588         return getCI().getOptFlag();

   589     }

   590 

   591     TieredFastDebugConfig() {

   592         initNames("tiered", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");

   593         init(getIncludes(), getDefines());

   594     }

   595 }

   596 

   597 

   598 abstract class ProductConfig extends BuildConfig {

   599     protected void init(Vector includes, Vector defines) {

   600         defines.add("NDEBUG");

   601         defines.add("PRODUCT");

   602 

   603         super.init(includes, defines);

   604 

   605         getV("CompilerFlags").addAll(getCI().getProductCompilerFlags());

   606         getV("LinkerFlags").addAll(getCI().getProductLinkerFlags());

   607     }

   608 }

   609 

   610 class C1ProductConfig extends ProductConfig {

   611     C1ProductConfig() {

   612         initNames("compiler1", "product", "jre\\bin\\client\\jvm.dll");

   613         init(getIncludes(), getDefines());

   614     }

   615 }

   616 

   617 class C2ProductConfig extends ProductConfig {

   618     C2ProductConfig() {

   619         initNames("compiler2", "product", "jre\\bin\\server\\jvm.dll");

   620         init(getIncludes(), getDefines());

   621     }

   622 }

   623 

   624 class TieredProductConfig extends ProductConfig {

   625     TieredProductConfig() {

   626         initNames("tiered", "product", "jre\\bin\\server\\jvm.dll");

   627         init(getIncludes(), getDefines());

   628     }

   629 }

   630 

   631 

   632 class CoreDebugConfig extends GenericDebugConfig {

   633     String getOptFlag() {

   634         return getCI().getNoOptFlag();

   635     }

   636 

   637     CoreDebugConfig() {

   638         initNames("core", "debug", "fastdebug\\jre\\bin\\core\\jvm.dll");

   639         init(getIncludes(), getDefines());

   640     }

   641 }

   642 

   643 

   644 class CoreFastDebugConfig extends GenericDebugConfig {

   645     String getOptFlag() {

   646         return getCI().getOptFlag();

   647     }

   648 

   649     CoreFastDebugConfig() {

   650         initNames("core", "fastdebug", "fastdebug\\jre\\bin\\core\\jvm.dll");

   651         init(getIncludes(), getDefines());

   652     }

   653 }

   654 

   655 

   656 class CoreProductConfig extends ProductConfig {

   657     CoreProductConfig() {

   658         initNames("core", "product", "jre\\bin\\core\\jvm.dll");

   659         init(getIncludes(), getDefines());

   660     }

   661 }

   662 

   663 class KernelDebugConfig extends GenericDebugConfig {

   664     String getOptFlag() {

   665         return getCI().getNoOptFlag();

   666     }

   667 

   668     KernelDebugConfig() {

   669         initNames("kernel", "debug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");

   670         init(getIncludes(), getDefines());

   671     }

   672 }

   673 

   674 

   675 class KernelFastDebugConfig extends GenericDebugConfig {

   676     String getOptFlag() {

   677         return getCI().getOptFlag();

   678     }

   679 

   680     KernelFastDebugConfig() {

   681         initNames("kernel", "fastdebug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");

   682         init(getIncludes(), getDefines());

   683     }

   684 }

   685 

   686 

   687 class KernelProductConfig extends ProductConfig {

   688     KernelProductConfig() {

   689         initNames("kernel", "product", "jre\\bin\\kernel\\jvm.dll");

   690         init(getIncludes(), getDefines());

   691     }

   692 }

   693 abstract class CompilerInterface {

   694     abstract Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir);

   695     abstract Vector getBaseLinkerFlags(String outDir, String outDll);

   696     abstract Vector getDebugCompilerFlags(String opt);

   697     abstract Vector getDebugLinkerFlags();

   698     abstract Vector getProductCompilerFlags();

   699     abstract Vector getProductLinkerFlags();

   700     abstract String getOptFlag();

   701     abstract String getNoOptFlag();

   702     abstract String makeCfgName(String flavourBuild);

   703 

   704     void addAttr(Vector receiver, String attr, String value) {

   705         receiver.add(attr); receiver.add(value);

   706     }

   707 }