How to use

Parser

in

ch.qos.logback.core.subst

private static Node tokenizeAndParseString(String value) throws ScanException {
 Tokenizer tokenizer = new Tokenizer(value);
 List<Token> tokens = tokenizer.tokenize();
 Parser parser = new Parser(tokens);
 return parser.parse();
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = peekAtCurentToken();
 if (isDefaultToken(t)) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

private Node E() throws ScanException {
 Node t = T();
 if (t == null) {
  return null;
 }
 Node eOpt = Eopt();
 if (eOpt != null) {
  t.append(eOpt);
 }
 return t;
}

private Node Eopt() throws ScanException {
 Token next = peekAtCurentToken();
 if (next == null) {
  return null;
 } else {
  return E();
 }
}

private Node T() throws ScanException {
 Token t = peekAtCurentToken();
 switch (t.type) {
  case LITERAL:
   advanceTokenPointer();
   return makeNewLiteralNode(t.payload);
  case CURLY_LEFT:
   advanceTokenPointer();
   Node innerNode = C();
   Token right = peekAtCurentToken();
   expectCurlyRight(right);
   advanceTokenPointer();
   Node curlyLeft = makeNewLiteralNode(CoreConstants.LEFT_ACCOLADE);
   curlyLeft.append(innerNode);
   curlyLeft.append(makeNewLiteralNode(CoreConstants.RIGHT_ACCOLADE));
   return curlyLeft;
  case START:
   advanceTokenPointer();
   Node v = V();
   Token w = peekAtCurentToken();
   expectCurlyRight(w);
   advanceTokenPointer();
   return v;
  default:
   return null;
 }
}

private Node T() throws ScanException {
 Token t = getCurentToken();
   advanceTokenPointer();
   return new Node(Node.Type.LITERAL, t.payload);
  case CURLY_LEFT:
   advanceTokenPointer();
   Node inner = E();
   Token right = getCurentToken();
   expectCurlyRight(right);
   advanceTokenPointer();
   Node curlyLeft = new Node(Node.Type.LITERAL, CoreConstants.LEFT_ACCOLADE);
   curlyLeft.next = inner;
    curlyLeft.next = curlyRightNode;
   else
    appendNode(inner, curlyRightNode);
   return curlyLeft;
  case START:
   advanceTokenPointer();
   Node v = V();
   Token w = getCurentToken();
   expectCurlyRight(w);
   advanceTokenPointer();
   return v;
  default:

private Node E() throws ScanException {
 Node t = T();
 if (t == null) {
  return null;
 }
 Node eOpt = Eopt();
 if (eOpt != null) {
  appendNode(t, eOpt);
 }
 return t;
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = getCurentToken();
 if (t != null && t.type == Token.Type.DEFAULT) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

public Node parse() throws ScanException {
 if(tokenList == null || tokenList.isEmpty())
  return null;
 return E();
}

void expectCurlyRight(Token t) throws ScanException {
 expectNotNull(t, "}");
 if (t.type != Token.Type.CURLY_RIGHT) {
  throw new ScanException("Expecting }");
 }
}

private Node Eopt() throws ScanException {
 Token next = getCurentToken();
 // System.out.println("Current token is " + next);
 if (next == null) {
  return null;
 } else {
  return E();
 }
}

private Node T() throws ScanException {
 Token t = peekAtCurentToken();
 switch (t.type) {
  case LITERAL:
   advanceTokenPointer();
   return makeNewLiteralNode(t.payload);
  case CURLY_LEFT:
   advanceTokenPointer();
   Node innerNode = C();
   Token right = peekAtCurentToken();
   expectCurlyRight(right);
   advanceTokenPointer();
   Node curlyLeft = makeNewLiteralNode(CoreConstants.LEFT_ACCOLADE);
   curlyLeft.append(innerNode);
   curlyLeft.append(makeNewLiteralNode(CoreConstants.RIGHT_ACCOLADE));
   return curlyLeft;
  case START:
   advanceTokenPointer();
   Node v = V();
   Token w = peekAtCurentToken();
   expectCurlyRight(w);
   advanceTokenPointer();
   return v;
  default:
   return null;
 }
}

private Node T() throws ScanException {
 Token t = getCurentToken();
   advanceTokenPointer();
   return new Node(Node.Type.LITERAL, t.payload);
  case CURLY_LEFT:
   advanceTokenPointer();
   Node inner = E();
   Token right = getCurentToken();
   expectCurlyRight(right);
   advanceTokenPointer();
   Node curlyLeft = new Node(Node.Type.LITERAL, CoreConstants.LEFT_ACCOLADE);
   curlyLeft.next = inner;
    curlyLeft.next = curlyRightNode;
   else
    appendNode(inner, curlyRightNode);
   return curlyLeft;
  case START:
   advanceTokenPointer();
   Node v = V();
   Token w = getCurentToken();
   expectCurlyRight(w);
   advanceTokenPointer();
   return v;
  default:

private Node Eopt() throws ScanException {
 Token next = peekAtCurentToken();
 if (next == null) {
  return null;
 } else {
  return E();
 }
}

private Node E() throws ScanException {
 Node t = T();
 if (t == null) {
  return null;
 }
 Node eOpt = Eopt();
 if (eOpt != null) {
  appendNode(t, eOpt);
 }
 return t;
}

private Node V() throws ScanException {
 Node e = E();
 Node variable = new Node(Node.Type.VARIABLE, e);
 Token t = getCurentToken();
 if (t != null && t.type == Token.Type.DEFAULT) {
  advanceTokenPointer();
  Node def = E();
  variable.defaultPart = def;
 }
 return variable;
}

public Node parse() throws ScanException {
 return E();
}

void expectCurlyRight(Token t) throws ScanException {
 expectNotNull(t, "}");
 if (t.type != Token.Type.CURLY_RIGHT) {
  throw new ScanException("Expecting }");
 }
}

private Node Eopt() throws ScanException {
 Token next = getCurentToken();
 // System.out.println("Current token is " + next);
 if (next == null) {
  return null;
 } else {
  return E();
 }
}

private Node C() throws ScanException {
 Node e0 = E();
 Token t = peekAtCurentToken();
 if (isDefaultToken(t)) {
  advanceTokenPointer();
  Node literal = makeNewLiteralNode(CoreConstants.DEFAULT_VALUE_SEPARATOR);
  e0.append(literal);
  Node e1 = E();
  e0.append(e1);
 }
 return e0;
}