How to use

createSymbol

method

in

org.matheclipse.parser.client.ast.IParserFactory

  /**
   * {@inheritDoc} Creates the function.
   */
  @Override
  public ASTNode createFunction( final IParserFactory factory, final ASTNode lhs, final ASTNode rhs ) {
    return factory.createFunction( factory.createSymbol( "Plus" ), lhs, factory.createFunction( factory.createSymbol( "Times" ), factory.createInteger( -1 ), rhs ) );
  }
}

  public ASTNode createFunction(final IParserFactory factory, final ASTNode lhs, final ASTNode rhs) {
    return factory.createFunction(factory.createSymbol("Plus"), lhs, factory.createFunction(factory.createSymbol("Times"), factory
        .createInteger(-1), rhs));

    // alternatively we can introduce a Subtract operator.
    // see http://code.google.com/p/symja/issues/detail?id=36
    // return factory.createFunction(factory.createSymbol("Subtract"), lhs,
    // rhs);
  }
}

  public ASTNode createFunction(final IParserFactory factory,
      final ASTNode lhs, final ASTNode rhs) {
    return factory.createFunction(factory.createSymbol(getFunctionName()),
        lhs, rhs);
  }
}

  public ASTNode createFunction(final IParserFactory factory,
      final ASTNode argument) {
    return factory.createFunction(factory.createSymbol(getFunctionName()),
        argument);
  }
}

  public ASTNode createFunction(final IParserFactory factory, final ASTNode argument) {
    return factory.createFunction(factory.createSymbol("Times"), factory.createInteger(-1), argument);

    // alternatively we can introduce a Minus operator.
    // see http://code.google.com/p/symja/issues/detail?id=36
    // return factory.createFunction(factory.createSymbol("Minus"), argument);
  }
}

  public ASTNode createFunction(final IParserFactory factory,
      final ASTNode argument) {
    return factory.createFunction(factory.createSymbol(getFunctionName()),
        argument);
  }
}

  /**
   * Creates the function.
   * 
   * @param factory the factory
   * @param argument the argument
   * @return the AST node
   */
  public ASTNode createFunction( final IParserFactory factory, final ASTNode argument ) {
    return factory.createFunction( factory.createSymbol( getFunctionName() ), argument );
  }
}

  /**
   * Creates the function.
   * 
   * @param factory the factory
   * @param lhs the lhs
   * @param rhs the rhs
   * @return the AST node
   */
  public ASTNode createFunction( final IParserFactory factory, final ASTNode lhs, final ASTNode rhs ) {
    return factory.createFunction( factory.createSymbol( getFunctionName() ), lhs, rhs );
  }
}

  /**
   * Creates the function.
   * 
   * @param factory the factory
   * @param argument the argument
   * @return the AST node
   */
  public ASTNode createFunction( final IParserFactory factory, final ASTNode argument ) {
    return factory.createFunction( factory.createSymbol( getFunctionName() ), argument );
  }
}

  /**
   * {@inheritDoc} Creates the function.
   */
  @Override
  public ASTNode createFunction( final IParserFactory factory, final ASTNode argument ) {
    return factory.createFunction( factory.createSymbol( "Times" ), factory.createInteger( -1 ), argument );
  }
}

  /**
   * {@inheritDoc} Creates the function.
   */
  @Override
  public ASTNode createFunction( final IParserFactory factory, final ASTNode lhs, final ASTNode rhs ) {
    if ( rhs instanceof IntegerNode ) {
      if ( lhs instanceof IntegerNode ) {
        return new FractionNode( (IntegerNode) lhs, (IntegerNode) rhs );
      }
      return factory.createFunction( factory.createSymbol( "Times" ), lhs, new FractionNode( IntegerNode.C1, (IntegerNode) rhs ) );
    }
    return factory.createFunction( factory.createSymbol( "Times" ), lhs, factory.createFunction( factory.createSymbol( "Power" ), rhs, factory.createInteger( -1 ) ) );
  }
}

  public ASTNode createFunction(final IParserFactory factory,
      final ASTNode lhs, final ASTNode rhs) {
    if (rhs instanceof IntegerNode) {
      if (lhs instanceof IntegerNode) {
        return new FractionNode((IntegerNode) lhs, (IntegerNode) rhs);
      }
      return factory.createFunction(factory.createSymbol("Times"), lhs,
          new FractionNode(IntegerNode.C1, (IntegerNode) rhs));
    }
    return factory.createFunction(factory.createSymbol("Times"), lhs,
        factory.createFunction(factory.createSymbol("Power"), rhs,
            factory.createInteger(-1)));
  }
}

/**
 * Read the current identifier from the expression factories table.
 * 
 * @return the symbol
 * @throws SyntaxError the syntax error
 * @see
 */
private SymbolNode getSymbol() throws SyntaxError {
  String identifier = getIdentifier();
  if ( !fFactory.isValidIdentifier( identifier ) ) {
    throwSyntaxError( "Invalid identifier: " + identifier + " detected." );
  }
  final SymbolNode symbol = fFactory.createSymbol( identifier );
  getNextToken();
  return symbol;
}

/**
 * Read the current identifier from the expression factories table
 * 
 * @return
 * @see
 */
private SymbolNode getSymbol() throws SyntaxError {
  String identifier = getIdentifier();
  if (!fFactory.isValidIdentifier(identifier)) {
    throwSyntaxError("Invalid identifier: " + identifier + " detected.");
  }
  final SymbolNode symbol = fFactory.createSymbol(identifier);
  getNextToken();
  return symbol;
}

function = fFactory.createFunction(fFactory.createSymbol(IConstantOperators.Part), temp);
function = fFactory.createFunction(fFactory.createSymbol(IConstantOperators.Part), function);

/**
 * Get a list {...}
 * 
 */
private ASTNode getList() throws SyntaxError {
  final FunctionNode function = fFactory.createFunction(fFactory.createSymbol(IConstantOperators.List));
  getNextToken();
  if (fToken == TT_LIST_CLOSE) {
    getNextToken();
    return function;
  }
  getArguments(function);
  if (fToken == TT_LIST_CLOSE) {
    getNextToken();
    return function;
  }
  throwSyntaxError("')' expected.");
  return null;
}

/**
 * Get a list {...}
 * 
 * @return the list
 * @throws SyntaxError the syntax error
 */
private ASTNode getList() throws SyntaxError {
  final FunctionNode function = fFactory.createFunction( fFactory.createSymbol( IConstantOperators.List ) );
  getNextToken();
  if ( fToken == TT_LIST_CLOSE ) {
    getNextToken();
    return function;
  }
  getArguments( function );
  if ( fToken == TT_LIST_CLOSE ) {
    getNextToken();
    return function;
  }
  throwSyntaxError( "')' expected." );
  return null;
}

final FunctionNode out = fFactory.createFunction( fFactory.createSymbol( IConstantOperators.Out ) );
final FunctionNode slot = fFactory.createFunction( fFactory.createSymbol( IConstantOperators.Slot ) );
if ( fToken == TT_DIGIT ) {
  slot.add( getNumber( false ) );
final FunctionNode slotSequencce = fFactory.createFunction( fFactory.createSymbol( IConstantOperators.SlotSequence ) );
if ( fToken == TT_DIGIT ) {
  slotSequencce.add( getNumber( false ) );

if ( oper.getPrecedence() >= min_precedence ) {
  rhs = parseLookaheadOperator( oper.getPrecedence() );
  lhs = fFactory.createFunction( fFactory.createSymbol( oper.getFunctionName() ), lhs, rhs );
  lhs = parseArguments( lhs );
  continue;

if (oper.getPrecedence() >= min_precedence) {
  rhs = parseLookaheadOperator(oper.getPrecedence());
  lhs = fFactory.createFunction(fFactory.createSymbol(oper.getFunctionName()), lhs, rhs);
  lhs = parseArguments(lhs);
  continue;