adds the IzouSoundLine as permanent
@param izouSoundLine the izouSoundLine to add
170678
private void addPermanent(IzouSoundLineBaseClass izouSoundLine) {
        debug("adding " + izouSoundLine + " to permanent");
        if (!izouSoundLine.isPermanent())
            izouSoundLine.setToPermanent();
        synchronized (permanentUserReadWriteLock) {
            endWaitingForUsage();
            if (permanentLines == null) {
                permanentLines = Collections.synchronizedList(new ArrayList<>());
            }
            permanentLines.add(new WeakReference<>(izouSoundLine));
        }
        //TODO: STOP the addon via the stop event
    }
98891
private void addToTail(final WComponent component) {
		WContainer tail = (WContainer) getDecoratedLabel().getTail();
		if (null != tail) { // bloody well better not be...
			tail.add(component);
		}
	}
226063
def add(self, indent, line):
        
        if isinstance(line, str):
            list.append(self, indent*4*' ' + line)
        else:
            for subline in line:
                list.append(self, indent*4*' ' + subline)
565096
public function addLine(Line $line)
    {
        $this->lines[] = $line;
        $this->end = $line->getIndex();
    }
1311636
public void addLocation(TaintLocation location, boolean isKnownTaintSource) {
        Objects.requireNonNull(location, "location is null");
        if (isKnownTaintSource) {
            taintLocations.add(location);
        } else {
            unknownLocations.add(location);
        }
    }
643297
public void add(long idx, int val) {
    	int curVal = getWithDefault(idx, ZERO);
    	put(idx, curVal + val);
    }
47913
public void add(int theOpCode, int theOperand) {
        if (DEBUGCODE) {
            System.out.println("Add " + bytecodeStr(theOpCode)
                + ", " + Integer.toHexString(theOperand));
        }
        int newStack = itsStackTop + stackChange(theOpCode);
        if (newStack < 0 || Short.MAX_VALUE < newStack)
            badStack(newStack);

        switch (theOpCode) {
            case ByteCode.GOTO:
                // This is necessary because dead code is seemingly being
                // generated and Sun's verifier is expecting type state to be
                // placed even at dead blocks of code.
                addSuperBlockStart(itsCodeBufferTop + 3);
                // fallthru...
            case ByteCode.IFEQ:
            case ByteCode.IFNE:
            case ByteCode.IFLT:
            case ByteCode.IFGE:
            case ByteCode.IFGT:
            case ByteCode.IFLE:
            case ByteCode.IF_ICMPEQ:
            case ByteCode.IF_ICMPNE:
            case ByteCode.IF_ICMPLT:
            case ByteCode.IF_ICMPGE:
            case ByteCode.IF_ICMPGT:
            case ByteCode.IF_ICMPLE:
            case ByteCode.IF_ACMPEQ:
            case ByteCode.IF_ACMPNE:
            case ByteCode.JSR:
            case ByteCode.IFNULL:
            case ByteCode.IFNONNULL: {
                if ((theOperand & 0x80000000) != 0x80000000) {
                    if ((theOperand < 0) || (theOperand > 65535))
                        throw new IllegalArgumentException(
                            "Bad label for branch");
                }
                int branchPC = itsCodeBufferTop;
                addToCodeBuffer(theOpCode);
                if ((theOperand & 0x80000000) != 0x80000000) {
                    // hard displacement
                    addToCodeInt16(theOperand);
                    int target = theOperand + branchPC;
                    addSuperBlockStart(target);
                    itsJumpFroms.put(target, branchPC);
                } else {  // a label
                    int targetPC = getLabelPC(theOperand);
                    if (DEBUGLABELS) {
                        int theLabel = theOperand & 0x7FFFFFFF;
                        System.out.println("Fixing branch to " +
                            theLabel + " at " + targetPC +
                            " from " + branchPC);
                    }
                    if (targetPC != -1) {
                        int offset = targetPC - branchPC;
                        addToCodeInt16(offset);
                        addSuperBlockStart(targetPC);
                        itsJumpFroms.put(targetPC, branchPC);
                    } else {
                        addLabelFixup(theOperand, branchPC + 1);
                        addToCodeInt16(0);
                    }
                }
            }
            break;

            case ByteCode.BIPUSH:
                if ((byte) theOperand != theOperand)
                    throw new IllegalArgumentException("out of range byte");
                addToCodeBuffer(theOpCode);
                addToCodeBuffer((byte) theOperand);
                break;

            case ByteCode.SIPUSH:
                if ((short) theOperand != theOperand)
                    throw new IllegalArgumentException("out of range short");
                addToCodeBuffer(theOpCode);
                addToCodeInt16(theOperand);
                break;

            case ByteCode.NEWARRAY:
                if (!(0 <= theOperand && theOperand < 256))
                    throw new IllegalArgumentException("out of range index");
                addToCodeBuffer(theOpCode);
                addToCodeBuffer(theOperand);
                break;

            case ByteCode.GETFIELD:
            case ByteCode.PUTFIELD:
                if (!(0 <= theOperand && theOperand < 65536))
                    throw new IllegalArgumentException("out of range field");
                addToCodeBuffer(theOpCode);
                addToCodeInt16(theOperand);
                break;

            case ByteCode.LDC:
            case ByteCode.LDC_W:
            case ByteCode.LDC2_W:
                if (!(0 <= theOperand && theOperand < 65536))
                    throw new ClassFileFormatException("out of range index");
                if (theOperand >= 256
                    || theOpCode == ByteCode.LDC_W
                    || theOpCode == ByteCode.LDC2_W) {
                    if (theOpCode == ByteCode.LDC) {
                        addToCodeBuffer(ByteCode.LDC_W);
                    } else {
                        addToCodeBuffer(theOpCode);
                    }
                    addToCodeInt16(theOperand);
                } else {
                    addToCodeBuffer(theOpCode);
                    addToCodeBuffer(theOperand);
                }
                break;

            case ByteCode.RET:
            case ByteCode.ILOAD:
            case ByteCode.LLOAD:
            case ByteCode.FLOAD:
            case ByteCode.DLOAD:
            case ByteCode.ALOAD:
            case ByteCode.ISTORE:
            case ByteCode.LSTORE:
            case ByteCode.FSTORE:
            case ByteCode.DSTORE:
            case ByteCode.ASTORE:
                if (theOperand < 0 || 65536 <= theOperand)
                    throw new ClassFileFormatException("out of range variable");
                if (theOperand >= 256) {
                    addToCodeBuffer(ByteCode.WIDE);
                    addToCodeBuffer(theOpCode);
                    addToCodeInt16(theOperand);
                } else {
                    addToCodeBuffer(theOpCode);
                    addToCodeBuffer(theOperand);
                }
                break;

            default:
                throw new IllegalArgumentException(
                    "Unexpected opcode for 1 operand");
        }

        itsStackTop = (short) newStack;
        if (newStack > itsMaxStack)
            itsMaxStack = (short) newStack;
        if (DEBUGSTACK) {
            System.out.println("After " + bytecodeStr(theOpCode)
                + " stack = " + itsStackTop);
        }
    }
1169270
public void addAll(IntBitRelation right) {
        int i, max;

        max = right.line.length;
        for (i = 0; i < max; i++) {
            if (right.line[i] != null) {
                add(i, right.line[i]);
            }
        }
    }
441176
public void add(Composite start, Composite end, long markedAt, int delTime)
    {
        if (isEmpty())
        {
            addInternal(0, start, end, markedAt, delTime);
            return;
        }

        int c = comparator.compare(ends[size-1], start);

        // Fast path if we add in sorted order
        if (c <= 0)
        {
            addInternal(size, start, end, markedAt, delTime);
        }
        else
        {
            // Note: insertFrom expect i to be the insertion point in term of interval ends
            int pos = Arrays.binarySearch(ends, 0, size, start, comparator);
            insertFrom((pos >= 0 ? pos : -pos-1), start, end, markedAt, delTime);
        }
        boundaryHeapSize += start.unsharedHeapSize() + end.unsharedHeapSize();
    }
643866
private void newLine() {
    numBlocks = 0;
    perms = username = group = path = linkTarget = replication = hardlinkId = "";
    filesize = 0l;
    type = INode.INodeType.REGULAR_INODE.toString();
    inInode = true;
  }
257110
public void addAddon(MapAddon addon) {
		if (null == addons) {
			addons = new ArrayList<MapAddon>();
		}
		addons.add(addon);
	}
1359087
private void addCommitDateInstantColumnIfNeeded() {
        if (!columnExists(getCommitTableNameWithSchema(), COMMIT_COMMIT_DATE_INSTANT)){
            addStringColumn(getCommitTableNameWithSchema(), COMMIT_COMMIT_DATE_INSTANT, 30);
        } else {
            extendStringColumnIfNeeded(getCommitTableNameWithSchema(), COMMIT_COMMIT_DATE_INSTANT, 30);
        }
    }
37257
private void addIfNotVisited(Object object, Class<?> clazz) {
    if (object != null && !visited.containsKey(object)) {
      toVisit.add(object);
      visited.put(object, clazz);
    }
  }
1283677
public void addPersistentRef()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "addPersistentRef");

        // We have at least one durable reference so the message
        // must maintain its level of persistence
        maintainPersistence = 1;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "addPersistentRef");
    }
17062
public final void setUtlInvLine(final UtlInvLine<RS, PurchaseReturn,
    PurchaseReturnLine, PurchaseReturnTaxLine,
      PurchaseReturnGoodsTaxLine> pUtlInvLine) {
    this.utlInvLine = pUtlInvLine;
  }
1151042
protected void addComment(ProgramElementDoc member, Content htmltree) {
        if (member.inlineTags().length > 0) {
            writer.addInlineComment(member, htmltree);
        }
    }
393093
protected void addParameters(ExecutableMemberDoc member, Content htmltree, int indentSize) {
        addParameters(member, true, htmltree, indentSize);
    }