Changeset 769

Show
Ignore:
Timestamp:
08/15/07 01:02:23 (1 year ago)
Author:
Gregor
Message:

sss/build.d, sss/main.d, sss/conf.d, sss/install.d: Added --debug option (see ticket #108).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/docs/ChangeLog

    r768 r769  
    1414        - Added --config file for testing alternative dsss.conf's (see ticket 
    1515          #109). 
     16        - Added --debug option (see ticket #108). 
    1617 
    17180.70 from 0.69: 

  • trunk/sss/build.d

    r728 r769  
    107107                    // usname = name_with_underscores 
    108108                    char[] usname = replace(build, std.path.sep, "_"); 
     109 
     110                    // if we aren't building a debug library, the debug conditional will fall through 
     111                    char[] debugPrefix = null; 
     112                    if (buildDebug) 
     113                        debugPrefix = "debug-"; 
    109114                     
    110115                    if (shLibSupport() && 
    …… 
    113118version (build) { 
    114119    version (DSSS_Static_` ~ usname ~ `) { 
    115         pragma(link, "S` ~ target ~ `"); 
     120        debug { 
     121            pragma(link, "S` ~ debugPrefix ~ target ~ `"); 
     122        } else { 
     123            pragma(link, "S` ~ target ~ `"); 
     124        } 
    116125    } else { 
    117126        pragma(link, "` ~ target ~ `"); 
    …… 
    122131                        std.file.write(ifile, std.file.read(file) ~ ` 
    123132version (build) { 
    124     pragma(link, "S` ~ target ~ `"); 
     133    debug { 
     134        pragma(link, "S` ~ debugPrefix ~ target ~ `"); 
     135    } else { 
     136        pragma(link, "S` ~ target ~ `"); 
     137    } 
    125138} 
    126139`); 
    …… 
    155168                char[][] shortshlibnames = getShortShLibNames(settings); 
    156169                char[] shlibflag = getShLibFlag(settings); 
    157                  
     170 
    158171                if (exists(shlibname)) continue; 
    159172                 
    …… 
    218231             
    219232            // and other necessary data 
    220             char[] shlibname = getShLibName(settings); 
    221             char[] shlibflag = getShLibFlag(settings); 
    222             char[] bflags; 
     233            char[] bflags, debugflags, releaseflags; 
    223234            if ("buildflags" in settings) { 
    224235                bflags = settings["buildflags"] ~ " "; 
     236            } 
     237            if ("debugflags" in settings) { 
     238                debugflags = settings["debugflags"] ~ " "; 
     239            } else { 
     240                debugflags = "-debug -gc "; 
     241            } 
     242            if ("releaseflags" in settings) { 
     243                releaseflags = settings["releaseflags"] ~ " "; 
    225244            } 
    226245             
    …… 
    244263                testLibs /* need to build the ilbrary to test it */) { 
    245264                 
     265                if (buildDebug) 
     266                    buildLibrary("debug-" ~ target, bl, bflags ~ debugflags, docbl, fileList, settings); 
     267                buildLibrary(target, bl, bflags ~ releaseflags, docbl, fileList, settings); 
     268            } 
     269         
     270            // do the postbuild 
     271            if ("postbuild" in settings) { 
     272                dsssScriptedStep(conf, settings["postbuild"]); 
     273            } 
     274             
     275            // an extra line for clarity 
     276            writefln(""); 
     277             
     278        } else if (type == "special") { 
     279            // special type, do pre/post 
     280            writefln("%s", target); 
     281            if ("prebuild" in settings) { 
     282                dsssScriptedStep(conf, settings["prebuild"]); 
     283            } 
     284             
     285            if ("postbuild" in settings) { 
     286                dsssScriptedStep(conf, settings["postbuild"]); 
     287            } 
     288            writefln(""); 
     289             
     290        } else if (type == "subdir") { 
     291            // recurse 
     292            char[] origcwd = getcwd(); 
     293            chdir(build); 
     294             
     295            // the one thing that's passed in is build flags 
     296            char[] orig_dsss_build = dsss_build.dup; 
     297            if ("buildflags" in settings) { 
     298                dsss_build ~= settings["buildflags"] ~ " "; 
     299            } 
     300             
     301            int buildret = sss.build.build(null); 
     302            chdir(origcwd); 
     303             
     304            dsss_build = orig_dsss_build; 
     305             
     306        }          
     307    } 
     308     
     309    // 4) Binaries 
     310    foreach (build; buildSources) { 
     311        char[][char[]] settings = conf.settings[build]; 
     312         
     313        // basic info 
     314        char[] type = settings["type"]; 
     315        char[] target = settings["target"]; 
     316         
     317        if (type == "binary") { 
     318            // our binary build line 
     319            char[] bflags; 
     320            if ("buildflags" in settings) { 
     321                bflags = settings["buildflags"]; 
     322            } 
     323            if (buildDebug) { 
     324                if ("debugflags" in settings) { 
     325                    bflags ~= " " ~ settings["debugflags"]; 
     326                } else { 
     327                    bflags ~= " -debug -gc"; 
     328                } 
     329            } else { 
     330                if ("releaseflags" in settings) { 
     331                    bflags ~= " " ~ settings["releaseflags"]; 
     332                } 
     333            } 
     334             
     335            char[] bbl = bl ~ bflags ~ " "; 
     336             
     337            // output what we're building 
     338            writefln("%s => %s", build, target); 
     339 
     340            // prepare for documentation 
     341            prepareDocs(build, doDocs && doDocBinaries); 
     342            bbl ~= docbl; 
     343             
     344            // do the prebuild 
     345            if ("prebuild" in settings) { 
     346                dsssScriptedStep(conf, settings["prebuild"]); 
     347            } 
     348             
     349            // build a build line 
     350            char[] ext = std.string.tolower(getExt(build)); 
     351            if (ext == "d") { 
     352                bbl ~= build ~ " -of" ~ target ~ " "; 
     353            } else if (ext == "brf") { 
     354                bbl ~= "@" ~ getName(build) ~ " "; 
     355            } else { 
     356                writefln("ERROR: I don't know how to build something with extension %s", ext); 
     357                return 1; 
     358            } 
     359             
     360            // then do it 
     361            saySystemRDie(bbl, "-rf", target ~ ".rf", deleteRFiles); 
     362             
     363            // do the postbuild 
     364            if ("postbuild" in settings) { 
     365                dsssScriptedStep(conf, settings["postbuild"]); 
     366            } 
     367             
     368            // an extra line for clarity 
     369            writefln(""); 
     370             
     371        } 
     372    } 
     373     
     374    return 0; 
     375} 
     376 
     377/** 
     378 * Helper function to build libraries 
     379 * 
     380 * Params: 
     381 *  target   = target file name (minus platform-specific parts) 
     382 *  bl       = the base build line 
     383 *  bflags   = build flags 
     384 *  docbl    = build flags for documentation ("" for no docs) 
     385 *  fileList = list of files to be compiled into the library 
     386 *  settings = settings for this section from DSSSConf 
     387 */ 
     388void buildLibrary(char[] target, char[] bl, char[] bflags, char[] docbl, 
     389                 char[] fileList, char[][char[]] settings) 
     390{ 
     391                char[] shlibname = getShLibName(settings); 
     392                char[][] shortshlibnames = getShortShLibNames(settings); 
     393                char[] shlibflag = getShLibFlag(settings); 
     394 
    246395                if (targetGNUOrPosix()) { 
    247396                    // first do a static library 
    …… 
    286435                    assert(0); 
    287436                } 
    288                  
    289             } 
    290          
    291             // do the postbuild 
    292             if ("postbuild" in settings) { 
    293                 dsssScriptedStep(conf, settings["postbuild"]); 
    294             } 
    295              
    296             // an extra line for clarity 
    297             writefln(""); 
    298              
    299         } else if (type == "special") { 
    300             // special type, do pre/post 
    301             writefln("%s", target); 
    302             if ("prebuild" in settings) { 
    303                 dsssScriptedStep(conf, settings["prebuild"]); 
    304             } 
    305              
    306             if ("postbuild" in settings) { 
    307                 dsssScriptedStep(conf, settings["postbuild"]); 
    308             } 
    309             writefln(""); 
    310              
    311         } else if (type == "subdir") { 
    312             // recurse 
    313             char[] origcwd = getcwd(); 
    314             chdir(build); 
    315              
    316             // the one thing that's passed in is build flags 
    317             char[] orig_dsss_build = dsss_build.dup; 
    318             if ("buildflags" in settings) { 
    319                 dsss_build ~= settings["buildflags"] ~ " "; 
    320             } 
    321              
    322             int buildret = sss.build.build(null); 
    323             chdir(origcwd); 
    324              
    325             dsss_build = orig_dsss_build; 
    326              
    327         }          
    328     } 
    329      
    330     // 4) Binaries 
    331     foreach (build; buildSources) { 
    332         char[][char[]] settings = conf.settings[build]; 
    333          
    334         // basic info 
    335         char[] type = settings["type"]; 
    336         char[] target = settings["target"]; 
    337          
    338         if (type == "binary") { 
    339             // our binary build line 
    340             char[] bflags; 
    341             if ("buildflags" in settings) { 
    342                 bflags = settings["buildflags"]; 
    343             } 
    344              
    345             char[] bbl = bl ~ bflags ~ " "; 
    346              
    347             // output what we're building 
    348             writefln("%s => %s", build, target); 
    349  
    350             // prepare for documentation 
    351             prepareDocs(build, doDocs && doDocBinaries); 
    352             bbl ~= docbl; 
    353              
    354             // do the prebuild 
    355             if ("prebuild" in settings) { 
    356                 dsssScriptedStep(conf, settings["prebuild"]); 
    357             } 
    358              
    359             // build a build line 
    360             char[] ext = std.string.tolower(getExt(build)); 
    361             if (ext == "d") { 
    362                 bbl ~= build ~ " -of" ~ target ~ " "; 
    363             } else if (ext == "brf") { 
    364                 bbl ~= "@" ~ getName(build) ~ " "; 
    365             } else { 
    366                 writefln("ERROR: I don't know how to build something with extension %s", ext); 
    367                 return 1; 
    368             } 
    369              
    370             // then do it 
    371             saySystemRDie(bbl, "-rf", target ~ ".rf", deleteRFiles); 
    372              
    373             // do the postbuild 
    374             if ("postbuild" in settings) { 
    375                 dsssScriptedStep(conf, settings["postbuild"]); 
    376             } 
    377              
    378             // an extra line for clarity 
    379             writefln(""); 
    380              
    381         } 
    382     } 
    383      
    384     return 0; 
    385437} 

  • trunk/sss/conf.d

    r762 r769  
    123123/** Should we generate test binaries? */ 
    124124bool testLibs = false; 
     125 
     126/** Should we build debug versions? */ 
     127bool buildDebug = false; 
    125128 
    126129/** The prefix for scratch work */ 

  • trunk/sss/install.d

    r768 r769  
    101101                // 1) .a 
    102102                copyAndManifest("libS" ~ target ~ ".a", libPrefix); 
     103 
     104                // and perhaps the debug version as well 
     105                if (buildDebug) 
     106                    copyAndManifest("libSdebug-" ~ target ~ ".a", libPrefix); 
    103107                 
    104108                char[] shlibname = getShLibName(settings); 

  • trunk/sss/main.d

    r768 r769  
    182182                doDocBinaries = true; 
    183183 
     184            } else if (parseArg(arg, "debug", false)) { 
     185                buildDebug = true; 
     186 
    184187            } else if (parseArg(arg, "prefix", true, &val)) { 
    185188                // force a prefix