llvm.org GIT mirror llvm / 5560c9d
Spell `necessary' correctly. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7944 91177308-0d34-0410-b5e6-96231b3b80d8 Misha Brukman 16 years ago
50 changed file(s) with 65 addition(s) and 65 deletion(s). Raw diff Collapse all Expand all
6767 provide it, allowing for powerful analyses and transformations to work well
6868 together.

6969
70 This document contains information neccesary to successfully implement this
70 This document contains information necessary to successfully implement this
7171 interface, use it, and to test both sides. It also explains some of the finer
7272 points about what exactly results mean. If you feel that something is unclear
7373 or should be added, please let me know.

9292 //===----------------------------------------------------------------------===//
9393
9494
95 A few things to note about this particular format. The "-*- C++ -*-" string on the first line is there to tell Emacs that the source file is a C++ file, not a C file (Emacs assumes .h files are C files by default [Note that tag this is not neccesary in .cpp files]). The name of the file is also on the first line, along with a very short description of the purpose of the file. This is important when printing out code and flipping though lots of pages.

95 A few things to note about this particular format. The "-*- C++ -*-" string on the first line is there to tell Emacs that the source file is a C++ file, not a C file (Emacs assumes .h files are C files by default [Note that tag this is not necessary in .cpp files]). The name of the file is also on the first line, along with a very short description of the purpose of the file. This is important when printing out code and flipping though lots of pages.

9696
9797 The main body of the description does not have to be very long in most cases. Here it's only two lines. If an algorithm is being implemented or something tricky is going on, a reference to the paper where it is published should be included, as well as any notes or "gotchas" in the code to watch out for.

9898
104104
105105

  • Method information
  • 106106
    107 Methods defined in a class (as well as any global functions) should also be documented properly. A quick note about what it does any a description of the borderline behaviour is all that is neccesary here (unless something particularly tricky or insideous is going on). The hope is that people can figure out how to use your interfaces without reading the code itself... that is the goal metric.

    107 Methods defined in a class (as well as any global functions) should also be documented properly. A quick note about what it does any a description of the borderline behaviour is all that is necessary here (unless something particularly tricky or insideous is going on). The hope is that people can figure out how to use your interfaces without reading the code itself... that is the goal metric.

    108108
    109109 Good things to talk about here are what happens when something unexpected happens: does the method return null? Abort? Format your hard disk?

    110110
    149149 Conditional move is effectly a special case of a predicated
    150150 instruction... and I think that all predicated instructions can possibly
    151151 be implemented later in LLVM. It would significantly change things, and
    152 it doesn't seem to be very neccesary right now. It would seem to
    152 it doesn't seem to be very necessary right now. It would seem to
    153153 complicate flow control analysis a LOT in the virtual machine. I would
    154154 tend to prefer that a predicated architecture like IA64 convert from a
    155155 "basic block" representation to a predicated rep as part of it's dynamic
    143143 2. A pointer to the dtor for the contained object
    144144 3. The contained object itself
    145145
    146 Note that it is neccesary to maintain #1 & #2 in the exception object itself
    146 Note that it is necessary to maintain #1 & #2 in the exception object itself
    147147 because objects without virtual function tables may be thrown (as in this
    148148 example). Assuming this, TryHandler would look something like this:
    149149
    4242
    4343 which is much more natural and what users expect.
    4444
    45 * Simplification of #include's: Before, it was neccesary for a .cpp file to
    45 * Simplification of #include's: Before, it was necessary for a .cpp file to
    4646 include every .h file that it used. Now things are batched a little bit more
    4747 to make it easier to use. Specifically, the include graph now includes these
    4848 edges:
    9191
    9292
  • Graphs - It would be great to have gnuplot graphs to keep track of how the
  • 9393 tree is changing over time. We already gather a several statistics, it
    94 just neccesary to add the script-fu to gnuplotize it.
    94 just necessary to add the script-fu to gnuplotize it.
    9595
    9696
  • Regression tests - We should run the regression tests in addition to the
  • 9797 program tests...
    14511451
  • Function::BasicBlockListType &getBasicBlockList()

  • 14521452
    14531453 Returns the list of BasicBlocks. This is
    1454 neccesary to use when you need to update the list or perform a complex action
    1454 necessary to use when you need to update the list or perform a complex action
    14551455 that doesn't have a forwarding method.

    14561456
    14571457
    14661466
  • Function::ArgumentListType &getArgumentList()

  • 14671467
    14681468 Returns the list of Arguments. This is
    1469 neccesary to use when you need to update the list or perform a complex action
    1469 necessary to use when you need to update the list or perform a complex action
    14701470 that doesn't have a forwarding method.

    14711471
    14721472
    15821582
  • Module::FunctionListType &getFunctionList()

  • 15831583
    15841584 Returns the list of Functions. This is
    1585 neccesary to use when you need to update the list or perform a complex action
    1585 necessary to use when you need to update the list or perform a complex action
    15861586 that doesn't have a forwarding method.

    15871587
    15881588
    16001600
  • Module::GlobalListType &getGlobalList()

  • 16011601
    16021602 Returns the list of GlobalVariables.
    1603 This is neccesary to use when you need to update the list or perform a complex
    1603 This is necessary to use when you need to update the list or perform a complex
    16041604 action that doesn't have a forwarding method.

    16051605
    16061606
    366366
    367367 When choosing a superclass for your Pass, you should choose the most
    368368 specific class possible, while still being able to meet the requirements
    369 listed. This gives the LLVM Pass Infrastructure information neccesary to
    369 listed. This gives the LLVM Pass Infrastructure information necessary to
    370370 optimize how passes are run, so that the resultant compiler isn't unneccesarily
    371371 slow.

    372372
    475475 pass. This pass converts malloc and free instructions into
    476476 platform dependant malloc() and free() function calls. It
    477477 uses the doInitialization method to get a reference to the malloc and
    478 free functions that it needs, adding prototypes to the module if neccesary.

    478 free functions that it needs, adding prototypes to the module if necessary.

    479479
    480480
    481481


    The runOnFunction method

    7272
    7373 /// addCustomGraphFeatures - If a graph is made up of more than just
    7474 /// straight-forward nodes and edges, this is the place to put all of the
    75 /// custom stuff neccesary. The GraphWriter object, instantiated with your
    75 /// custom stuff necessary. The GraphWriter object, instantiated with your
    7676 /// GraphType is passed in as an argument. You may call arbitrary methods on
    7777 /// it to add things to the output graph.
    7878 ///
    108108 // computer RPO from a graph. Because of this, the construction of the
    109109 // ReversePostOrderTraversal object is expensive (it must walk the entire graph
    110110 // with a postorder iterator to build the data structures). The moral of this
    111 // story is: Don't create more ReversePostOrderTraversal classes than neccesary.
    111 // story is: Don't create more ReversePostOrderTraversal classes than necessary.
    112112 //
    113113 // This class should be used like this:
    114114 // {
    108108 // computer RPO from a graph. Because of this, the construction of the
    109109 // ReversePostOrderTraversal object is expensive (it must walk the entire graph
    110110 // with a postorder iterator to build the data structures). The moral of this
    111 // story is: Don't create more ReversePostOrderTraversal classes than neccesary.
    111 // story is: Don't create more ReversePostOrderTraversal classes than necessary.
    112112 //
    113113 // This class should be used like this:
    114114 // {
    7676 /// AccessType - Keep track of whether this alias set merely refers to the
    7777 /// locations of memory, whether it modifies the memory, or whether it does
    7878 /// both. The lattice goes from "NoModRef" to either Refs or Mods, then to
    79 /// ModRef as neccesary.
    79 /// ModRef as necessary.
    8080 ///
    8181 enum AccessType {
    8282 NoModRef = 0, Refs = 1, // Ref = bit 1
    9595 virtual void print(std::ostream &OS) const;
    9696
    9797 /// dominates - Return true if A dominates B. This performs the special
    98 /// checks neccesary if A and B are in the same basic block.
    98 /// checks necessary if A and B are in the same basic block.
    9999 ///
    100100 bool dominates(Instruction *A, Instruction *B) const;
    101101
    132132 if (Done) return *this; // Found a new interval! Use it!
    133133 }
    134134
    135 // Free interval memory... if neccesary
    135 // Free interval memory... if necessary
    136136 if (IOwnMem) delete IntStack.top().first;
    137137
    138138 // We ran out of successors for this interval... pop off the stack
    44 //
    55 // Using the routines defined in this file does not require linking to any
    66 // libraries, as all of the services are small self contained units that are to
    7 // be inlined as neccesary.
    7 // be inlined as necessary.
    88 //
    99 //===----------------------------------------------------------------------===//
    1010
    8080
    8181 /// print - Print out the internal state of the pass. This is called by
    8282 /// Analyze to print out the contents of an analysis. Otherwise it is not
    83 /// neccesary to implement this method. Beware that the module pointer MAY be
    83 /// necessary to implement this method. Beware that the module pointer MAY be
    8484 /// null. This automatically forwards to a virtual function that does not
    8585 /// provide the Module* in case the analysis doesn't need it it can just be
    8686 /// ignored.
    238238 ///
    239239 struct FunctionPass : public Pass {
    240240 /// doInitialization - Virtual method overridden by subclasses to do
    241 /// any neccesary per-module initialization.
    241 /// any necessary per-module initialization.
    242242 ///
    243243 virtual bool doInitialization(Module &M) { return false; }
    244244
    284284 ///
    285285 struct BasicBlockPass : public FunctionPass {
    286286 /// doInitialization - Virtual method overridden by subclasses to do
    287 /// any neccesary per-module initialization.
    287 /// any necessary per-module initialization.
    288288 ///
    289289 virtual bool doInitialization(Module &M) { return false; }
    290290
    291291 /// doInitialization - Virtual method overridden by BasicBlockPass subclasses
    292 /// to do any neccesary per-function initialization.
    292 /// to do any necessary per-function initialization.
    293293 ///
    294294 virtual bool doInitialization(Function &F) { return false; }
    295295
    7272
    7373 /// addCustomGraphFeatures - If a graph is made up of more than just
    7474 /// straight-forward nodes and edges, this is the place to put all of the
    75 /// custom stuff neccesary. The GraphWriter object, instantiated with your
    75 /// custom stuff necessary. The GraphWriter object, instantiated with your
    7676 /// GraphType is passed in as an argument. You may call arbitrary methods on
    7777 /// it to add things to the output graph.
    7878 ///
    154154
    155155
    156156 // Specific Instruction type classes... note that all of the casts are
    157 // neccesary because we use the instruction classes as opaque types...
    157 // necessary because we use the instruction classes as opaque types...
    158158 //
    159159 RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);}
    160160 RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);}
    6060 unsigned char getPointerSize() const { return PointerSize; }
    6161 AnnotationID getStructLayoutAID() const { return AID; }
    6262
    63 // getTypeSize - Return the number of bytes neccesary to hold the specified
    63 // getTypeSize - Return the number of bytes necessary to hold the specified
    6464 // type
    6565 uint64_t getTypeSize (const Type *Ty) const;
    6666
    129129
    130130 // Remove duplicates from the CandidateLoads list because alias analysis
    131131 // processing may be somewhat expensive and we don't want to do more work
    132 // than neccesary.
    132 // than necessary.
    133133 //
    134134 unsigned OldSize = CandidateLoads.size();
    135135 std::sort(CandidateLoads.begin(), CandidateLoads.end());
    106106
    107107 if (I != GlobalRefs.end()) {
    108108 GlobalVariable *OldGV = I->second; // Get the placeholder...
    109 I->first.second.destroy(); // Free string memory if neccesary
    109 I->first.second.destroy(); // Free string memory if necessary
    110110
    111111 // Loop over all of the uses of the GlobalValue. The only thing they are
    112112 // allowed to be is ConstantPointerRef's.
    664664 Module *R = Parser.ParseBytecode(Buffer, Buffer+Length, ModuleID);
    665665 if (ErrorStr) *ErrorStr = Parser.getError();
    666666
    667 delete [] PtrToDelete; // Delete alignment buffer if neccesary
    667 delete [] PtrToDelete; // Delete alignment buffer if necessary
    668668 return R;
    669669 }
    670670
    5757 void AllocateBasicBlock(MachineBasicBlock &MBB);
    5858
    5959 /// getStackSpaceFor - This returns the offset of the specified virtual
    60 /// register on the stack, allocating space if neccesary.
    60 /// register on the stack, allocating space if necessary.
    6161 int getStackSpaceFor(unsigned VirtReg, const TargetRegisterClass *RC);
    6262
    6363 /// Given a virtual register, return a compatible physical register that is
    353353 void *Args[] = { Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, 0 };
    354354
    355355 // Loop over the format string, munging read values as appropriate (performs
    356 // byteswaps as neccesary).
    356 // byteswaps as necessary).
    357357 unsigned ArgNo = 0;
    358358 while (*Fmt) {
    359359 if (*Fmt++ == '%') {
    923923 }
    924924
    925925 // Specific Instruction type classes... note that all of the casts are
    926 // neccesary because we use the instruction classes as opaque types...
    926 // necessary because we use the instruction classes as opaque types...
    927927 //
    928928 void CWriter::visitReturnInst(ReturnInst &I) {
    929929 // Don't output a void return if this is the last basic block in the function
    10231023 printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
    10241024 }
    10251025 } else {
    1026 // First goto not neccesary, assume second one is...
    1026 // First goto not necessary, assume second one is...
    10271027 Out << " if (!";
    10281028 writeOperand(I.getCondition());
    10291029 Out << ") {\n";
    923923 }
    924924
    925925 // Specific Instruction type classes... note that all of the casts are
    926 // neccesary because we use the instruction classes as opaque types...
    926 // necessary because we use the instruction classes as opaque types...
    927927 //
    928928 void CWriter::visitReturnInst(ReturnInst &I) {
    929929 // Don't output a void return if this is the last basic block in the function
    10231023 printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
    10241024 }
    10251025 } else {
    1026 // First goto not neccesary, assume second one is...
    1026 // First goto not necessary, assume second one is...
    10271027 Out << " if (!";
    10281028 writeOperand(I.getCondition());
    10291029 Out << ") {\n";
    0 //===-- EmitAssembly.cpp - Emit Sparc Specific .s File ---------------------==//
    11 //
    2 // This file implements all of the stuff neccesary to output a .s file from
    2 // This file implements all of the stuff necessary to output a .s file from
    33 // LLVM. The code in this file assumes that the specified module has already
    44 // been compiled into the internal data structures of the Module.
    55 //
    8989 }
    9090
    9191 // enterSection - Use this method to enter a different section of the output
    92 // executable. This is used to only output neccesary section transitions.
    92 // executable. This is used to only output necessary section transitions.
    9393 //
    9494 void enterSection(enum Sections S) {
    95 if (S == CurSection) return; // Only switch section if neccesary
    95 if (S == CurSection) return; // Only switch section if necessary
    9696 CurSection = S;
    9797
    9898 toAsm << "\n\t.section ";
    1414 #include "llvm/DerivedTypes.h"
    1515 #include "llvm/Constants.h"
    1616
    17 // Handle the Pass registration stuff neccesary to use TargetData's.
    17 // Handle the Pass registration stuff necessary to use TargetData's.
    1818 namespace {
    1919 // Register the default SparcV9 implementation...
    2020 RegisterPass X("targetdata", "Target Data Layout");
    4444 getTypeInfo(Ty, &TD, TySize, A);
    4545 TyAlign = A;
    4646
    47 // Add padding if neccesary to make the data element aligned properly...
    47 // Add padding if necessary to make the data element aligned properly...
    4848 if (StructSize % TyAlign != 0)
    4949 StructSize = (StructSize/TyAlign + 1) * TyAlign; // Add padding...
    5050
    184184 if (Reg >= X86::FP0 && Reg <= X86::FP6) {
    185185 DEBUG(std::cerr << "Register FP#" << Reg-X86::FP0 << " is dead!\n");
    186186 ++I; // Insert fxch AFTER the instruction
    187 moveToTop(Reg-X86::FP0, I); // Insert fxch if neccesary
    187 moveToTop(Reg-X86::FP0, I); // Insert fxch if necessary
    188188 --I; // Move to fxch or old instruction
    189189 popStackAfter(I); // Pop the top of the stack, killing value
    190190 }
    448448 unsigned Opcode = MI.getOpcode();
    449449 const TargetInstrDescriptor &Desc = II->get(Opcode);
    450450
    451 // Emit instruction prefixes if neccesary
    451 // Emit instruction prefixes if necessary
    452452 if (Desc.TSFlags & X86II::OpSize) MCE.emitByte(0x66);// Operand size...
    453453
    454454 switch (Desc.TSFlags & X86II::Op0Mask) {
    184184 if (Reg >= X86::FP0 && Reg <= X86::FP6) {
    185185 DEBUG(std::cerr << "Register FP#" << Reg-X86::FP0 << " is dead!\n");
    186186 ++I; // Insert fxch AFTER the instruction
    187 moveToTop(Reg-X86::FP0, I); // Insert fxch if neccesary
    187 moveToTop(Reg-X86::FP0, I); // Insert fxch if necessary
    188188 --I; // Move to fxch or old instruction
    189189 popStackAfter(I); // Pop the top of the stack, killing value
    190190 }
    8181 }
    8282
    8383 // hasSPAdjust - Return true if this function has ESP adjustment instructions in
    84 // the prolog and epilog which allocate local stack space. This is neccesary
    84 // the prolog and epilog which allocate local stack space. This is necessary
    8585 // because we elide these instructions if there are no function calls in the
    8686 // current function (ie, this is a leaf function). In this case, we can refer
    8787 // beyond the stack pointer because we know that nothing will trample on that
    709709 if (CTMI != CTMap.end()) { // Operand #1 is in the table already?
    710710 // If so, check to see if it's Ty*, or, more importantly, if it is a
    711711 // pointer to a structure where the first element is a Ty... this code
    712 // is neccesary because we might be trying to change the source and
    712 // is necessary because we might be trying to change the source and
    713713 // destination type of the store (they might be related) and the dest
    714714 // pointer type might be a pointer to structure. Below we allow pointer
    715715 // to structures where the 0th element is compatible with the value,
    863863
    864864 // Okay, at this point, we know that all of the arguments can be
    865865 // converted. We succeed if we can change the return type if
    866 // neccesary...
    866 // necessary...
    867867 //
    868868 return ValueConvertibleToType(I, FTy->getReturnType(), CTMap, TD);
    869869 }
    132132 ++NumRaised;
    133133 } else if (CI->getCalledValue() == FreeFunc) { // Replace call to free?
    134134 // If no prototype was provided for free, we may need to cast the
    135 // source pointer. This should be really uncommon, but it's neccesary
    135 // source pointer. This should be really uncommon, but it's necessary
    136136 // just in case we are dealing with wierd code like this:
    137137 // free((long)ptr);
    138138 //
    207207 std::set AliveBlocks;
    208208
    209209 // Process the work list of instructions that just became live... if they
    210 // became live, then that means that all of their operands are neccesary as
    210 // became live, then that means that all of their operands are necessary as
    211211 // well... make them live as well.
    212212 //
    213213 while (!WorkList.empty()) {
    176176 // X = -(A+12+C+D) into X = -A + -12 + -C + -D = -12 + -A + -C + -D
    177177 // so that later, a: Y = 12+X could get reassociated with the -12 to eliminate
    178178 // the constants. We assume that instcombine will clean up the mess later if
    179 // we introduce tons of unneccesary negation instructions...
    179 // we introduce tons of unnecessary negation instructions...
    180180 //
    181181 if (Instruction *I = dyn_cast(V))
    182182 if (I->getOpcode() == Instruction::Add && I->use_size() == 1) {
    131131 }
    132132
    133133 // getValueState - Return the InstVal object that corresponds to the value.
    134 // This function is neccesary because not all values should start out in the
    134 // This function is necessary because not all values should start out in the
    135135 // underdefined state... Argument's should be overdefined, and
    136136 // constants should be marked as constants. If a value is not known to be an
    137137 // Instruction object, then use this accessor to get its value from the map.
    2222
    2323 std::string OldName = I.getName();
    2424
    25 // Delete the unneccesary instruction now...
    25 // Delete the unnecessary instruction now...
    2626 BI = BIL.erase(BI);
    2727
    2828 // Make sure to propagate a name if there is one already...
    1212 // as store-sinking that is built into LICM.
    1313 //
    1414 // Note that the simplifycfg pass will clean up blocks which are split out but
    15 // end up being unneccesary, so usage of this pass does not neccesarily
    15 // end up being unnecessary, so usage of this pass does not neccesarily
    1616 // pessimize generated code.
    1717 //
    1818 //===----------------------------------------------------------------------===//
    9696 if (MI->getNumOperands() && Size == 1) {
    9797 MallocArg = MI->getOperand(0); // Operand * 1 = Operand
    9898 } else if (MI->getNumOperands()) {
    99 // Multiply it by the array size if neccesary...
    99 // Multiply it by the array size if necessary...
    100100 MallocArg = BinaryOperator::create(Instruction::Mul, MI->getOperand(0),
    101101 MallocArg, "", I);
    102102 }
    201201 // correct number of entries for their predecessors.
    202202 Value *NullVal = Constant::getNullValue(PN->getType());
    203203
    204 // This is neccesary because adding incoming values to the PHI node adds uses
    204 // This is necessary because adding incoming values to the PHI node adds uses
    205205 // to the basic blocks being used, which can invalidate the predecessor
    206206 // iterator!
    207207 std::vector Preds(pred_begin(BB), pred_end(BB));
    2020 A("domset", "Dominator Set Construction", true);
    2121
    2222 // dominates - Return true if A dominates B. This performs the special checks
    23 // neccesary if A and B are in the same basic block.
    23 // necessary if A and B are in the same basic block.
    2424 //
    2525 bool DominatorSetBase::dominates(Instruction *A, Instruction *B) const {
    2626 BasicBlock *BBA = A->getParent(), *BBB = B->getParent();
    176176 }
    177177
    178178 // print - Print out the internal state of the pass. This is called by Analyse
    179 // to print out the contents of an analysis. Otherwise it is not neccesary to
    179 // to print out the contents of an analysis. Otherwise it is not necessary to
    180180 // implement this method.
    181181 //
    182182 void Pass::print(std::ostream &O) const {
    259259 "Function return type does not match operand "
    260260 "type of return inst!", &RI, F->getReturnType());
    261261
    262 // Check to make sure that the return value has neccesary properties for
    262 // Check to make sure that the return value has necessary properties for
    263263 // terminators...
    264264 visitTerminatorInst(RI);
    265265 }
    129129 abort();
    130130 } else { // This class expects template arguments...
    131131 // Loop over all of the template arguments, setting them to the specified
    132 // value or leaving them as the default as neccesary.
    132 // value or leaving them as the default as necessary.
    133133 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
    134134 if (i < TemplateArgs.size()) { // A value is specified for this temp-arg?
    135135 // Set it now.
    0 /* This triggered a problem in reload, fixed by disabling most of the
    11 * steps of compilation in GCC. Before this change, the code went through
    2 * the entire backend of GCC, even though it was unneccesary for LLVM output
    2 * the entire backend of GCC, even though it was unnecessary for LLVM output
    33 * now it is skipped entirely, and since reload doesn't run, it can't cause
    44 * a problem.
    55 */
    319319 std::cout << "\n*** Attempting to reduce testcase by deleting instruc"
    320320 << "tions: Simplification Level #" << Simplification << "\n";
    321321
    322 // Now that we have deleted the functions that are unneccesary for the
    323 // program, try to remove instructions that are not neccesary to cause the
    322 // Now that we have deleted the functions that are unnecessary for the
    323 // program, try to remove instructions that are not necessary to cause the
    324324 // crash. To do this, we loop through all of the instructions in the
    325325 // remaining functions, deleting them (replacing any values produced with
    326326 // nulls), and then running ADCE and SimplifyCFG. If the transformed input
    6767 break;
    6868 case NoFailure:
    6969 // Otherwise the property doesn't hold. Some of the elements we removed
    70 // must be neccesary to maintain the property.
    70 // must be necessary to maintain the property.
    7171 MidTop = Mid;
    7272 break;
    7373 }
    66 miscompiles one function of a large benchmark), and so you want to just
    77 cut the testcase down to the one function that is being a problem. In
    88 this case, 'extract' eliminates all of the extraneous global variables,
    9 type information, and functions that aren't neccesary, giving you
    9 type information, and functions that aren't necessary, giving you
    1010 something simpler.
    1111
    1212 This is just an FYI, because I've found it useful and thought you guys
    129129 abort();
    130130 } else { // This class expects template arguments...
    131131 // Loop over all of the template arguments, setting them to the specified
    132 // value or leaving them as the default as neccesary.
    132 // value or leaving them as the default as necessary.
    133133 for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
    134134 if (i < TemplateArgs.size()) { // A value is specified for this temp-arg?
    135135 // Set it now.