build/buildlib.xs

   1 /******************************************************************************
   2  * FILE PURPOSE: Build Library Utilities
   3  ******************************************************************************
   4  * FILE NAME: buildlib.xs
   5  *
   6  * DESCRIPTION:
   7  *  This file contains common routines that are used by the various McBSP
   8  *  driver components.
   9  *
  10  * Copyright (C) 2012, Texas Instruments, Inc.
  11  *****************************************************************************/
  12
  13 /**************************************************************************
  14  * FUNCTION NAME : createMiniPkg
  15  **************************************************************************
  16  * DESCRIPTION   :
  17  *  The function is responsible for creating the mini tar package
  18  *  The MINI package has the following files:-
  19  *      - Driver Source Files.
  20  *      - Header files (exported and internal driver files)
  21  *      - Simple Makefiles.
  22  **************************************************************************/
  23 function createMiniPkg(pkgName)
  24 {
  25     /* Get the package Name. */
  26     var packageRepository = xdc.getPackageRepository(Pkg.name);
  27     var packageBase       = xdc.getPackageBase(Pkg.name);
  28     var packageName       = packageBase.substring(packageRepository.length + 1);
  29
  30     /* Convert the Package name by replacing back slashes with forward slashes. This is required because
  31      * otherwise with long names the tar is unable to change directory. */
  32     var newPkgName = new java.lang.String(packageRepository);
  33     var newPkgRep  = newPkgName.replace('\\', '/');
  34
  35     /* Step1: Create the MINI Package and add the simple Big and Little Endian Makefiles to the package */
  36     Pkg.makeEpilogue += "release: mini_pkg\n";
  37     Pkg.makeEpilogue += "mini_pkg:\n";
  38     Pkg.makeEpilogue += "\t tar -C " + "\"" + newPkgRep + "\"" + " -cf packages/" + pkgName + "_mini.tar " + packageName + "simpleC66LE.mak "  + packageName + "simpleC66BE.mak\n";
  39
  40     /* Step2: Add the exported header files to the package */
  41     var includeFiles = libUtility.listAllFiles (".h", ".", false);
  42     for (var k = 0 ; k < includeFiles.length; k++)
  43         Pkg.makeEpilogue += "\t tar -C " + "\"" + newPkgRep + "\"" + " -rf packages/" + pkgName + "_mini.tar " + packageName + includeFiles[k] + "\n";
  44
  45     /* Step3: Add the internal header files to the package */
  46     includeFiles = libUtility.listAllFiles (".h", "include", true);
  47     for (var k = 0 ; k < includeFiles.length; k++)
  48         Pkg.makeEpilogue += "\t tar -C " + "\"" + newPkgRep + "\"" + " -rf packages/" + pkgName + "_mini.tar " + packageName + includeFiles[k] + "\n";
  49
  50     includeFiles = libUtility.listAllFiles (".h", "device", true);
  51     for (var k = 0 ; k < includeFiles.length; k++)
  52         Pkg.makeEpilogue += "\t tar -C " + "\"" + newPkgRep + "\"" + " -rf packages/" + pkgName + "_mini.tar " + packageName + includeFiles[k] + "\n";
  53
  54     /* Step4: Add the device McBSP file (Example file) which illustrates McBSP device initialization. */
  55     var deviceSrcFiles = libUtility.listAllFiles (".c", "device", true);
  56     for (var k = 0 ; k < deviceSrcFiles.length; k++)
  57         Pkg.makeEpilogue += "\t tar -C " + "\"" + newPkgRep + "\"" + " -rf packages/" + pkgName + "_mini.tar " + packageName + deviceSrcFiles[k] + "\n";
  58
  59     /* Step5: Add the driver source files to the package; the filter should have generated a source listing */
  60     Pkg.makeEpilogue += "\t tar -C " + "\"" + newPkgRep + "\"" + " -T src.lst -rf packages/" + pkgName + "_mini.tar " + "\n";
  61
  62     /* Ensure that we clean up the mini package */
  63     Pkg.makeEpilogue += "clean::\n";
  64     Pkg.makeEpilogue += "\t $(RM) packages/" + pkgName + "_mini.tar\n";
  65 }
  66
  67 /**************************************************************************
  68  * FUNCTION NAME : listAllFiles
  69  **************************************************************************
  70  * DESCRIPTION   :
  71  *  Utility function which lists all files with a specific extension
  72  *  present in a directory and any directory inside it.
  73  **************************************************************************/
  74 function listAllFiles(ext, dir, recurse)
  75 {
  76     var srcFile = [];
  77     var d;
  78
  79     /* If recurse parameter is not specified we default to recursive search. */
  80     if (recurse == null)
  81         recurse = true;
  82
  83     if (dir == undefined)
  84             d = ".";
  85     else
  86         d = dir;
  87
  88     /* Get access to the current directory. */
  89     var file = new java.io.File(d);
  90
  91     /* Check if the file exists and it is a directory. */
  92     if (file.exists() && file.isDirectory())
  93     {
  94         /* Get a list of all files in the specific directory. */
  95         var fileList = file.listFiles();
  96         for (var i = 0; i < fileList.length; i++)
  97         {
  98             /* Dont add the generated directory 'package' and any of its files
  99              * to the list here. */
 100             if (fileList[i].getName().matches("package") == false)
 101             {
 102                 /* Check if the detected file is a directory */
 103                 if (fileList[i].isDirectory())
 104                 {
 105                     /* We will recurse into the subdirectory only if required to do so. */
 106                     if (recurse == true)
 107                     {
 108                         /* Generate the directory Name in which we will recurse. */
 109                         var directoryName = d + "/" + fileList[i].getName();
 110
 111                         /* Get a list of all files in this directory */
 112                         var fileListing = listAllFiles (ext, directoryName, recurse);
 113                         if (fileListing != null)
 114                         {
 115                             /* Return a list of all file names in the directory. */
 116                             for (var j = 0 ; j < fileListing.length; j++)
 117                                 srcFile[srcFile.length++] = fileListing[j];
 118                         }
 119                     }
 120                 }
 121                 else
 122                 {
 123                     /* This was a file. Check if the file name matches the extension */
 124                     if (fileList[i].getName().endsWith(ext) == true)
 125                         srcFile[srcFile.length++] = d + "/" + fileList[i].getName();
 126                 }
 127             }
 128         }
 129         return srcFile;
 130     }
 131     return null;
 132 }
 133
 134 function createMake(makefile)
 135 {
 136     /* Create the main make file */
 137     var fileModule = xdc.module('xdc.services.io.File');
 138     if(makefile==undefined)
 139     {
 140       try{
 141           makefile = fileModule.open("makefile", "w");
 142          } catch (ex)
 143          {
 144            print("makefile cannot be written to. Please check Writing Permissions.");
 145            java.lang.System.exit(1);
 146          }
 147
 148       Pkg.makePrologue += "\ninclude makefile\n";
 149
 150       Pkg.makeEpilogue += "\nclean::\n\t-$(RM)  makefile\n";
 151       makefile.writeLine("#*******************************************************************************");
 152       makefile.writeLine("#* FILE PURPOSE: Top level makefile for Creating Component Libraries");
 153       makefile.writeLine("#*******************************************************************************");
 154       makefile.writeLine("#* FILE NAME: makefile");
 155       makefile.writeLine("#*");
 156       makefile.writeLine("#* DESCRIPTION: Defines Compiler tools paths, libraries , Build Options ");
 157       makefile.writeLine("#*");
 158       makefile.writeLine("#*");
 159       makefile.writeLine("#*******************************************************************************");
 160       makefile.writeLine("#*");
 161       makefile.writeLine("# (Mandatory) Specify where various tools are installed.");
 162
 163       var file = xdc.module('xdc.services.io.File');
 164
 165       var xdcTargetType = java.lang.System.getenv("XDCTARGET");
 166       var toolsBaseDir = java.lang.System.getenv("XDCCGROOT");
 167
 168       makefile.writeLine("\n# Output for prebuilt generated libraries");
 169       makefile.writeLine("export LIBDIR ?= ./lib");
 170
 171       /* Create INCDIR from XDCPATH */
 172
 173       /* copy the environment array from the current environment */
 174       var env   = java.lang.System.getenv();
 175       var getxdcpath=String(java.lang.System.getenv("XDCPATH"));
 176       getxdcpath= getxdcpath.replace(/\\/g,"/");
 177       var keys  = env.keySet().toArray();
 178       var key;
 179       var stat={};
 180       var env_j=[];
 181       var listxdcpath = new Array();
 182       for (var i = 0; i < keys.length; i++) {
 183            key = String(keys[i]);
 184            if((key.match("INSTALL_PATH")) || (key.match("INSTALLDIR")))
 185            {
 186              var keyPath=String(env.get(key));
 187              keyPath=keyPath.replace(/\\/g,"/");
 188              var file = xdc.module('xdc.services.io.File');
 189              keyPath=file.getDOSPath(keyPath);
 190              if(getxdcpath.toString().match(keyPath))
 191              {
 192                  listxdcpath.push({keyname: key,keypath: keyPath});
 193                  while(getxdcpath.toString().match(keyPath))
 194                  {
 195                    getxdcpath=getxdcpath.toString().replace(keyPath,"$("+key+")");
 196                  }
 197              }
 198            }
 199
 200      }
 201        var pkgroot="..";
 202        for (var i = Pkg.name.split('.').length; i > 1; i--) {
 203               pkgroot+="/..";
 204           }
 205
 206       makefile.writeLine("\n# ROOT Directory");
 207       makefile.writeLine("export ROOTDIR := "+pkgroot);
 208
 209       makefile.writeLine("\n# INCLUDE Directory");
 210       makefile.writeLine("export INCDIR := "+getxdcpath+";$(ROOTDIR)");
 211
 212       makefile.writeLine("\n# Common Macros used in make");
 213       makefile.writeLine("\nifndef RM");
 214       makefile.writeLine("export RM = rm -f");
 215       makefile.writeLine("endif");
 216
 217       makefile.writeLine("\nifndef CP");
 218       makefile.writeLine("export CP = cp -p");
 219       makefile.writeLine("endif");
 220
 221       makefile.writeLine("\nexport MKDIR = mkdir -p");
 222
 223       makefile.writeLine("\nifndef RMDIR");
 224       makefile.writeLine("export RMDIR = rm -rf");
 225       makefile.writeLine("endif");
 226
 227       makefile.writeLine("\nifndef SED");
 228       makefile.writeLine("export SED = sed");
 229       makefile.writeLine("endif");
 230
 231       makefile.writeLine("\nifndef MAKE");
 232       makefile.writeLine("export MAKE = make");
 233       makefile.writeLine("endif");
 234
 235       makefile.writeLine("\n# PHONY Targets");
 236       makefile.writeLine(".PHONY: all clean cleanall ");
 237
 238       makefile.writeLine("\n# FORCE Targets");
 239       makefile.writeLine("FORCE: ");
 240
 241       makefile.writeLine("\n# all rule");
 242       makefile.writeLine("all: .executables");
 243       makefile.writeLine(".executables: .libraries");
 244       makefile.writeLine(".libraries:");
 245
 246       makefile.writeLine("\n# Clean Rule");
 247       makefile.writeLine("clean:: clean_package");
 248       makefile.writeLine("# Clean Top Level Object Directory ");
 249       makefile.writeLine("clean_package :\n\t$(RMDIR) $(LIBDIR)/*/");
 250       makefile.writeLine("\t$(RMDIR) package/cfg");
 251    }
 252    else
 253    {
 254      try{
 255           makefile = fileModule.open("makefile", "a");
 256          } catch (ex)
 257          {
 258            print("makefile cannot be written to. Please check Writing Permissions.");
 259            java.lang.System.exit(1);
 260          }
 261
 262     }
 263
 264  return makefile;
 265 }
 266
 267 function createLibMake(makelibname,targetname, objectPath)
 268 {
 269    var tooldir;
 270    var stringname=String(targetname).replace("(xdc.bld.ITarget.Module)","");
 271    if(stringname.match("ARM11"))
 272    {
 273      tooldir="TI_ARM11_GEN_INSTALL_PATH";
 274    }
 275    else
 276    {
 277      tooldir="C6X_GEN_INSTALL_PATH";
 278    }
 279    switch(stringname)
 280    {
 281     case String(C66LE):
 282       targetname=C66LE;
 283       break;
 284     case String(C66BE):
 285       targetname=C66BE;
 286       break;
 287     case String(C67LE):
 288       targetname=C67LE;
 289       break;
 290
 291    }
 292     var fileModule = xdc.module('xdc.services.io.File');
 293     try{
 294      var dstFile = new java.io.File(makelibname);
 295      dstFile.getParentFile().mkdirs();
 296      libmakefile = fileModule.open(makelibname, "w");
 297      /* Add to Archive list */
 298     } catch (ex)
 299     {
 300      print(makelibname+" cannot be written to. Please check Writing Permissions.");
 301      java.lang.System.exit(1);
 302     }
 303     libmakefile.writeLine("#*******************************************************************************");
 304     libmakefile.writeLine("#* FILE PURPOSE: Lower level makefile for Creating Component Libraries");
 305     libmakefile.writeLine("#*******************************************************************************");
 306     libmakefile.writeLine("#* FILE NAME: "+makelibname);
 307     libmakefile.writeLine("#*");
 308     libmakefile.writeLine("#* DESCRIPTION: Defines Source Files, Compilers flags and build rules");
 309     libmakefile.writeLine("#*");
 310     libmakefile.writeLine("#*");
 311     libmakefile.writeLine("#*******************************************************************************");
 312     libmakefile.writeLine("#");
 313     libmakefile.writeLine("");
 314     libmakefile.writeLine("#");
 315     libmakefile.writeLine("# Macro definitions referenced below");
 316     libmakefile.writeLine("#");
 317     libmakefile.writeLine("empty =");
 318     libmakefile.writeLine("space =$(empty) $(empty)");
 319
 320     if(stringname.match("ti.targets"))
 321     {
 322
 323        var rtslibtemp = targetname.lnkOpts.suffix.toString().split("/");
 324        var rtslib;
 325        for(n=0;n<rtslibtemp.length;n++)
 326        {
 327           if(rtslibtemp[n].match(".lib"))
 328           {
 329              rtslib=rtslibtemp[n];
 330           }
 331        }
 332
 333       libmakefile.writeLine("CC = $("+tooldir+")/bin/"+targetname.cc.cmd +" "+targetname.ccOpts.prefix+" "+targetname.cc.opts);
 334       libmakefile.writeLine("AC = $("+tooldir+")/bin/"+targetname.asm.cmd +" "+targetname.asmOpts.prefix+" "+targetname.asm.opts);
 335       libmakefile.writeLine("ARIN = $("+tooldir+")/bin/"+targetname.ar.cmd +" "+targetname.ar.opts);
 336       libmakefile.writeLine("LD = $("+tooldir+")/bin/"+targetname.lnk.cmd +" "+targetname.lnk.opts);
 337       libmakefile.writeLine("RTSLIB = -l $("+tooldir+")/lib/"+rtslib);
 338     }
 339     else
 340     {
 341       print("Error: Non-TI targets are not currently supported ");
 342       java.lang.System.exit(1);
 343
 344     }
 345
 346     libmakefile.writeLine("INCS = -I. -I$(strip $(subst ;, -I,$(subst $(space),\\$(space),$(INCDIR))))");
 347     libmakefile.writeLine("OBJEXT = o"+targetname.suffix);
 348     libmakefile.writeLine("AOBJEXT = s"+targetname.suffix);
 349     /* libmakefile.writeLine("INTERNALDEFS = -D"+stringname.replace(/\./g,"_")+" -Dxdc_target_types__=ti/targets/std.h -DMAKEFILE_BUILD -eo.$(OBJEXT) -ea.$(AOBJEXT) -fr=$(@D) -fs=$(@D) -ppa -ppd=$@.dep");*/
 350     libmakefile.writeLine("INTERNALDEFS = -D"+stringname.replace(/\./g,"_")+"  -DMAKEFILE_BUILD -eo.$(OBJEXT) -ea.$(AOBJEXT) -fr=$(@D) -fs=$(@D) -ppa -ppd=$@.dep");
 351     libmakefile.writeLine("INTERNALLINKDEFS = -o $@ -m $@.map");
 352           libmakefile.writeLine("OBJDIR =  $(LIBDIR)");
 353
 354  return libmakefile;
 355
 356 }
 357
 358 function makeAddObjects(srcString, makefilename, srcfiles, flags,fileExt, targetName)
 359 {
 360   var  sourcestring = (srcString + fileExt).toString().toUpperCase();
 361   var  compileflagstring = sourcestring + "FLAGS";
 362   var  objectliststring = sourcestring + "OBJS";
 363   /* List all the source files */
 364   makefilename.writeLine("\n#List the "+srcString+" Files");
 365   makefilename.writeLine(sourcestring + "= \\");
 366   for(var i=0;i<srcfiles.length-1;i++)
 367   {
 368     makefilename.writeLine("    "+srcfiles[i]+"\\");
 369   }
 370     makefilename.writeLine("    "+srcfiles[i]+"\n");
 371
 372  /* Flags for the source files */
 373  makefilename.writeLine("# FLAGS for the "+srcString+" Files");
 374  var compileflags="";
 375  if(fileExt == "asm" && flags.aopts != undefined)
 376  {
 377    compileflags+=" "+flags.aopts;
 378  }
 379  else if((fileExt == "c" || fileExt == "sa")&& flags.copts != undefined)
 380  {
 381    compileflags+=" "+flags.copts;
 382  }
 383
 384  if(flags.incs != undefined)
 385  {
 386    compileflags+=" "+flags.incs;
 387  }
 388
 389
 390  makefilename.writeLine(compileflagstring+" = "+compileflags +" \n");
 391  makefilename.writeLine("# Make Rule for the "+srcString+" Files");
 392
 393  makefilename.writeLine(objectliststring +" = $(patsubst %."+fileExt+", $(OBJDIR)/%.$(OBJEXT), $(" + sourcestring + "))");
 394  makefilename.writeLine("\n$("+objectliststring+"): $(OBJDIR)/%.$(OBJEXT): %."+fileExt);
 395  if(fileExt == "c")
 396  {
 397    makefilename.writeLine("\t-@echo cl"+targetName.suffix +" $< ...");
 398  }
 399  else
 400  {
 401    makefilename.writeLine("\t-@echo asm"+targetName.suffix +" $< ...");
 402  }
 403  makefilename.writeLine("\tif [ ! -d $(@D) ]; then $(MKDIR) $(@D) ; fi;");
 404
 405  if(fileExt == "c")
 406  {
 407    makefilename.writeLine("\t$(RM) $@.dep");
 408    makefilename.writeLine("\t$(CC) $("+compileflagstring+") $(INTERNALDEFS) $(INCS) -fc $< ");
 409    makefilename.writeLine("\t-@$(CP) $@.dep $@.pp; \\");
 410    makefilename.writeLine("         $(SED) -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\\\$$//' \\");
 411    makefilename.writeLine("             -e '/^$$/ d' -e 's/$$/ :/' < $@.pp >> $@.dep; \\");
 412    makefilename.writeLine("         $(RM) $@.pp ");
 413  }
 414  else if(fileExt == "asm")
 415  {
 416    makefilename.writeLine("\t$(AC) $("+compileflagstring+") $(INTERNALDEFS) $(INCS) -fa $< ");
 417  }
 418  else if(fileExt == "sa")
 419  {
 420    makefilename.writeLine("\t$(AC) $("+compileflagstring+") $(INTERNALDEFS) $(INCS) $< ");
 421  }
 422    makefilename.writeLine("\n#Create Empty rule for dependency");
 423    makefilename.writeLine("$("+objectliststring+"):"+makefilename.$private.fd);
 424    makefilename.writeLine(makefilename.$private.fd+":");
 425    makefilename.writeLine("\n#Include Depedency for "+srcString+" Files");
 426    makefilename.writeLine("ifneq (clean,$(MAKECMDGOALS))");
 427    makefilename.writeLine(" -include $("+objectliststring+":%.$(OBJEXT)=%.$(OBJEXT).dep)");
 428    makefilename.writeLine("endif");
 429
 430 }
 431
 432 /**************************************************************************
 433  * FUNCTION NAME : buildLibrary
 434  **************************************************************************
 435  * DESCRIPTION   :
 436  *  Utility function which will build a specific library
 437  **************************************************************************/
 438 var makefilelocal;
 439 function buildLibrary (libOptions, libName, target, libFiles)
 440 {
 441     var lldFullLibraryPath = "./lib/" + libName;
 442     var lldFullLibraryPathMake = "$(LIBDIR)/" + libName;
 443
 444     /* Create Main make file in the root of package folder */
 445     makefilelocal = createMake(makefilelocal);
 446
 447     /* Write the rule to make library in main makefile */
 448     lib = lldFullLibraryPath+".a"+target.suffix;
 449     libMake = lldFullLibraryPathMake+".a"+target.suffix;
 450     var objectPath= "./package/lib/"+lldFullLibraryPath;
 451     makefilelocal.writeLine("\n\n# Make rule to create "+libMake+" library");
 452     makefilelocal.writeLine(".libraries: "+ libMake);
 453     makefilelocal.writeLine(libMake+": FORCE\n\t$(MAKE) -f "+lib+".mk $@");
 454
 455     /* Create Library make file in the lib folder */
 456     var makefilelib= createLibMake(lib+".mk",target,objectPath);
 457
 458     /* Rule to clean library in main makefile */
 459     makefilelocal.writeLine("# Rule to clean "+libMake+" library");
 460     makefilelocal.writeLine("clean ::\n\t$(RM) "+ libMake);
 461     librule="\n\n"+libMake+" :";
 462
 463     /* Add files to be compiled */
 464     /* Separate out the C and assembly files */
 465     var cfiles= new Array();
 466     var afiles= new Array();
 467     var safiles= new Array();
 468     for each(var srcFile in libFiles)
 469     {
 470         var srcFile=String(srcFile);
 471         var dot = srcFile.lastIndexOf(".");
 472         var extension = srcFile.substr(dot,srcFile.length);
 473         if(extension == ".c")
 474         {
 475           cfiles.push(srcFile);
 476         }
 477         else if(extension == ".sa")
 478         {
 479           safiles.push(srcFile);
 480         }
 481         else if(extension == ".asm")
 482         {
 483            afiles.push(srcFile);
 484         }
 485         else
 486         {
 487            print("ERROR: Unsupported file extension");
 488            java.lang.System.exit(1);
 489         }
 490      }
 491     if(cfiles.length > 0)
 492     {
 493       makeAddObjects("COMMONSRC",makefilelib,cfiles,libOptions,"c",target);
 494       librule += " $(COMMONSRCCOBJS)";
 495     }
 496     if(afiles.length > 0)
 497     {
 498       makeAddObjects("COMMONSRC",makefilelib,afiles,libOptions,"asm",target);
 499       librule += " $(COMMONSRCSOBJS)";
 500     }
 501     if(safiles.length > 0)
 502     {
 503       makeAddObjects("COMMONSRC",makefilelib,safiles,libOptions,"sa",target);
 504       librule += " $(COMMONSRCSAOBJS)";
 505     }
 506
 507     makefilelib.writeLine(librule);
 508     makefilelib.writeLine("\t@echo archiving $? into $@ ...");
 509                 makefilelib.writeLine("\t$(ARIN) $@ $?");
 510                 makefilelib.close();
 511
 512     /* Create the library file and add all the objects to the file. */
 513     var lib = Pkg.addLibrary(lldFullLibraryPath, target, libOptions);
 514
 515     lib.addObjects (libFiles);
 516
 517     /* Create the Epilogue; which executes after all the builds are completed.
 518      * This is used to generate the benchmark information for the built library.
 519      * Also add the benchmarking information file to the package. */
 520     Pkg.makeEpilogue += ".libraries: benchmarking_" + target.suffix + "\n";
 521     Pkg.makeEpilogue += "benchmarking_" + target.suffix + ":";
 522     Pkg.makeEpilogue += "\n\t ofd6x.exe -x " + lldFullLibraryPath + ".a" + target.suffix + " > tmp.xml";
 523     Pkg.makeEpilogue += "\n\t sectti.exe tmp.xml > " + lldFullLibraryPath + ".a" + target.suffix +  "_size.txt";
 524     Pkg.makeEpilogue += "\n\t $(RM) tmp.xml\n\n";
 525     Pkg.otherFiles[Pkg.otherFiles.length++] = lldFullLibraryPath + ".a" + target.suffix + "_size.txt";
 526     Pkg.otherFiles[Pkg.otherFiles.length++] = lldFullLibraryPath + ".a" + target.suffix + ".mk";
 527
 528     /* We need to clean after ourselves; extend the 'clean' target to take care of this. */
 529     Pkg.makeEpilogue += "clean::\n\t";
 530     Pkg.makeEpilogue += "$(RM) " + lldFullLibraryPath + ".a" + target.suffix + "_size.txt\n\n";
 531
 532     return lib;
 533 }
 534