构造函数调用方式：
new Constructor( 左括号, 右括号, 表达式 )
或者
new Constructor( 括号, 表达式 ), 该构造函数转换成上面的构造函数，是： new Constructor( 括号, 括号, 表达式 )
@param left 左括号
@param right 右括号
@param exp 表达式
502276
function(left, right, exp) {
                    this.callBase();
                    this.setFlag("Brackets");
                    // 参数整理
                    if (arguments.length === 2) {
                        exp = right;
                        right = left;
                    }
                    this.leftSymbol = left;
                    this.rightSymbol = right;
                    this.setOperator(new BracketsOperator());
                    this.setOperand(exp, 0);
                }
234907
public boolean add(int left, int right) {
        if (line[left] == null) {
            line[left] = new IntBitSet();
        } else {
            if (line[left].contains(right)) {
                return false;
            }
        }

        line[left].add(right);
        return true;
    }
133141
public static <K, V> MergeResult<K, V> mergeRightIntoLeft(LinkedOptionalMap<K, V> left, LinkedOptionalMap<K, V> right) {
		LinkedOptionalMap<K, V> merged = new LinkedOptionalMap<>(left);
		merged.putAll(right);

		return new MergeResult<>(merged, isLeftPrefixOfRight(left, right));
	}
1171589
public BinaryTree leftBinarize() {
        BinaryTree leftChild;
        BinaryTree rightChild;
        if (isLeaf()) {
            leftChild = null;
            rightChild = null;
        } else if (children.size() == 1) {
            leftChild = children.get(0).leftBinarize();
            rightChild = null;
        } else if (children.size() == 2) {
            leftChild = children.get(0).leftBinarize();
            rightChild = children.get(1).leftBinarize();
        } else {
            // Define the label of the new parent node as in the Berkeley grammar.
            String xbarParent = GrammarConstants.getBinarizedTag(symbol);
            
            LinkedList<NaryTree> queue = new LinkedList<NaryTree>(children);
            // Start by binarizing the left-most child, and store as L.
            leftChild = queue.removeFirst().leftBinarize();
            while (true) {
                // Working left-to-right, remove and binarize the next-left-most child, and store as R.
                rightChild = queue.removeFirst().leftBinarize();
                // Break once we've acquired the right-most child.
                if (queue.isEmpty()) {
                    break;
                }
                // Then form a new binary node that has left/right children: L and R.
                // That is, a node (@symbolStr --> (L) (R)).
                // Store this new node as L and repeat.
                leftChild = new BinaryTree(xbarParent, leftChild.getStart(),
                        rightChild.getEnd(), leftChild, rightChild, isLexical);
            }
        }
        return new BinaryTree(symbol, start, end, leftChild, rightChild , isLexical);                
    }
460544
public AsymmMultiPos<S, String, String> betn(String left, String right) {
		return new AsymmMultiPos<S, String, String>(left, right) {

			@Override protected S result() {
				if (Strs.isEmpty(asymmLR)) {
					return aQueue('S', left, right, pos, position, inclusive, plusminus, filltgt);
				} else { return aQueue('Z', left, right, pos, asymmLR, inclusive, plusminus, filltgt); }
			}
		};
	}
700809
public boolean evaluate(InternalWorkingMemory workingMemory, Object left, Object right) {
        Object leftValue = leftTimestamp != null ? leftTimestamp : left;
        Object rightValue = rightTimestamp != null ? rightTimestamp : right;

        return rightLiteral ?
                evaluator.evaluate( workingMemory,
                                    new ConstantValueReader( leftValue ),
                                    dummyFactHandleOf( leftValue ),
                                    new ObjectFieldImpl( rightValue ) ) :
                evaluator.evaluate( workingMemory,
                                    new ConstantValueReader( leftValue ),
                                    dummyFactHandleOf( leftValue ),
                                    new ConstantValueReader( rightValue ),
                                    dummyFactHandleOf( rightValue ) );
    }
306459
protected AEqualsBinaryExp getEqualsExp(PExp left, PExp right)
	{
		return AstExpressionFactory.newAEqualsBinaryExp(left.clone(), right.clone());
	}
680085
public void composeLeftLeftInv(IntBitRelation left, IntBitRelation right) {
        int i, a, b;
        IntBitSet li, ri;

        for (i = 0; i < line.length; i++) {
            li = left.line[i];
            ri = right.line[i];
            if (li != null && ri != null) {
                for (a = li.first(); a != -1; a = li.next(a)) {
                    for (b = ri.first(); b != -1; b = ri.next(b)) {
                        add(b, a);
                    }
                }
            }
        }
    }
911894
public static <L, R> Either<L, R> leftOf(L reference) {
        require(reference != null, "Expected non-null reference");
        return new Left<>(reference);
    }
962652
public static BooleanIsNotEqual isNotEqual(ComparableExpression<Boolean> left, ComparableExpression<Boolean> right) {
        return new BooleanIsNotEqual(left, right);
    }
1172518
private Expression concat( Expression left, char operator, Expression right ) {
        if( left == null ) {
            return right;
        }
        Operation op;
        if( left.getClass() == Operation.class && ((Operation)left).getOperator() == operator ) {
            op = (Operation)left;
        } else if( right != null && right.getClass() == Operation.class && ((Operation)right).getOperator() == operator ) {
            op = (Operation)right;
            op.addLeftOperand( left );
            return op;
        } else {
            op = new Operation( reader, left, operator );
        }
        if( right != null ) {
            op.addOperand( right );
        }
        return op;
    }
486466
def init(self, left_end_needle, right_end_needle):
        
        if not isinstance(left_end_needle, int):

            raise TypeError(_left_end_needle_error_message(left_end_needle))
        if left_end_needle < 0 or left_end_needle > 198:
            raise ValueError(_left_end_needle_error_message(left_end_needle))
        if not isinstance(right_end_needle, int):
            raise TypeError(_right_end_needle_error_message(right_end_needle))
        if right_end_needle < 1 or right_end_needle > 199:
            raise ValueError(_right_end_needle_error_message(right_end_needle))
        self._left_end_needle = left_end_needle
        self._right_end_needle = right_end_needle
1030789
public static GeoEquals geoEquals(Expression<Geometry> left, Expression<Geometry> right) {
        return new GeoEquals(left, right);
    }
547905
public static CharSequence concat(CharSequence left, CharSequence right) {
	if (left instanceof Appendable) {
	    try {
		((Appendable) left).append(right);
		return left;
	    }
	    catch (IOException e) {}
	}
	return new StringBuilder(left).append(right);
    }
188915
public static Boolean and(Object left, Object right) {
        return (Boolean) InfixOpNode.and(left, right, null);
    }
99372
public static Expression compare(
      final int comparisonOpcode, final Expression left, final Expression right) {
    checkArgument(
        left.resultType().equals(right.resultType()),
        "left and right must have matching types, found %s and %s",
        left.resultType(),
        right.resultType());
    checkIntComparisonOpcode(left.resultType(), comparisonOpcode);
    Features features =
        Expression.areAllCheap(left, right) ? Features.of(Feature.CHEAP) : Features.of();
    return new Expression(Type.BOOLEAN_TYPE, features) {
      @Override
      protected void doGen(CodeBuilder mv) {
        left.gen(mv);
        right.gen(mv);
        Label ifTrue = mv.newLabel();
        Label end = mv.newLabel();
        mv.ifCmp(left.resultType(), comparisonOpcode, ifTrue);
        mv.pushBoolean(false);
        mv.goTo(end);
        mv.mark(ifTrue);
        mv.pushBoolean(true);
        mv.mark(end);
      }
    };
  }
337136
public static Object newInstance(Class type) {
        Constructor _constructor = null;
        Object[] _constructorArgs = new Object[0];
        try {
            _constructor = type.getConstructor(new Class[] {});// 先尝试默认的空构造函数
        } catch (NoSuchMethodException e) {
            // ignore
        }

        if (_constructor == null) {// 没有默认的构造函数，尝试别的带参数的函数
            Constructor[] constructors = type.getConstructors();
            if (constructors.length == 0) {
                throw new UnsupportedOperationException("Class[" + type.getName() + "] has no public constructors");
            }
            _constructor = constructors[0];// 默认取第一个参数
            Class[] params = _constructor.getParameterTypes();
            _constructorArgs = new Object[params.length];
            for (int i = 0; i < params.length; i++) {
                _constructorArgs[i] = getDefaultValue(params[i]);
            }
        }

        return ReflectUtils.newInstance(_constructor, _constructorArgs);
    }