sacparser.java

cssparser -- CSS 的语法解析器。采用java语言编写。可用在服务端生成页面。

            {if (true) return (pred == null)
                ? c
                : _conditionFactory.createAndCondition(pred, c);}
      break;
    case FUNCTION:
      t = jj_consume_token(FUNCTION);
                             function = unescape(t.image);
      label_47:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case S:
          ;
          break;
        default:
          jj_la1[76] = jj_gen;
          break label_47;
        }
        jj_consume_token(S);
      }
      t = jj_consume_token(IDENT);
                          arg = unescape(t.image);
      label_48:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case S:
          ;
          break;
        default:
          jj_la1[77] = jj_gen;
          break label_48;
        }
        jj_consume_token(S);
      }
      jj_consume_token(RROUND);
                if (function.equalsIgnoreCase("lang(")) {
                    c = _conditionFactory.createLangCondition(unescape(arg));
                    {if (true) return (pred == null)
                        ? c
                        : _conditionFactory.createAndCondition(pred, c);}
                } else {
                    {if (true) throw new CSSParseException(
                        "Invalid pseudo function name " + function,
                        getLocator());}
                }
      break;
    default:
      jj_la1[78] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public Condition hash(Condition pred) throws ParseException {
    Token t;
    t = jj_consume_token(HASH);
        Condition c = _conditionFactory.createIdCondition(t.image.substring(1));
        {if (true) return (pred == null) ? c : _conditionFactory.createAndCondition(pred, c);}
    throw new Error("Missing return statement in function");
  }

  final public void styleDeclaration() throws ParseException {
    jj_consume_token(LBRACE);
    label_49:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case S:
        ;
        break;
      default:
        jj_la1[79] = jj_gen;
        break label_49;
      }
      jj_consume_token(S);
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IDENT:
      declaration();
      break;
    default:
      jj_la1[80] = jj_gen;
      ;
    }
    label_50:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SEMICOLON:
        ;
        break;
      default:
        jj_la1[81] = jj_gen;
        break label_50;
      }
      jj_consume_token(SEMICOLON);
      label_51:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case S:
          ;
          break;
        default:
          jj_la1[82] = jj_gen;
          break label_51;
        }
        jj_consume_token(S);
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IDENT:
        declaration();
        break;
      default:
        jj_la1[83] = jj_gen;
        ;
      }
    }
    jj_consume_token(RBRACE);
  }

//
// declaration
//   : property ':' S* expr prio?
//   |
//   ;
//
  final public void declaration() throws ParseException {
  String p;
  LexicalUnit e;
  boolean priority = false;
//  CSSValue e;
  boolean noError = true;
    try {
      p = property();
      jj_consume_token(COLON);
      label_52:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case S:
          ;
          break;
        default:
          jj_la1[84] = jj_gen;
          break label_52;
        }
        jj_consume_token(S);
      }
      e = expr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IMPORTANT_SYM:
        priority = prio();
        break;
      default:
        jj_la1[85] = jj_gen;
        ;
      }
            _docHandler.property(p, e, priority);
    } catch (ParseException ex) {
        System.err.println("Exception in declaration()");
        noError = false;
        error_skipdecl();
    }
  }

//
// prio
//   : IMPORTANT_SYM S*
//   ;
//
  final public boolean prio() throws ParseException {
    jj_consume_token(IMPORTANT_SYM);
    label_53:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case S:
        ;
        break;
      default:
        jj_la1[86] = jj_gen;
        break label_53;
      }
      jj_consume_token(S);
    }
    {if (true) return true;}
    throw new Error("Missing return statement in function");
  }

//
// expr
//   : term [ operator term ]*
//   ;
//
// TODO: Deal with the operator
//
  final public LexicalUnit expr() throws ParseException {
    LexicalUnit head;
    LexicalUnit body;
    head = term(null);
                        body = head;
    label_54:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
      case SLASH:
      case PLUS:
      case MINUS:
      case HASH:
      case STRING:
      case URI:
      case INHERIT:
      case EMS:
      case EXS:
      case LENGTH_PX:
      case LENGTH_CM:
      case LENGTH_MM:
      case LENGTH_IN:
      case LENGTH_PT:
      case LENGTH_PC:
      case ANGLE_DEG:
      case ANGLE_RAD:
      case ANGLE_GRAD:
      case TIME_MS:
      case TIME_S:
      case FREQ_HZ:
      case FREQ_KHZ:
      case DIMEN:
      case PERCENTAGE:
      case NUMBER:
      case RGB:
      case FUNCTION:
      case IDENT:
      case UNICODERANGE:
        ;
        break;
      default:
        jj_la1[87] = jj_gen;
        break label_54;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
      case SLASH:
        body = operator(body);
        break;
      default:
        jj_la1[88] = jj_gen;
        ;
      }
      body = term(body);
    }
      {if (true) return head;}
    throw new Error("Missing return statement in function");
  }

//
// term
//   : unary_operator?
//     [ NUMBER S* | PERCENTAGE S* | LENGTH S* | EMS S* | EXS S* | ANGLE S* |
//       TIME S* | FREQ S* | function ]
//   | STRING S* | IDENT S* | URI S* | RGB S* | UNICODERANGE S* | hexcolor
//   ;
//
  final public LexicalUnit term(LexicalUnit prev) throws ParseException {
  Token t;
  char op = ' ';
  String s;
  LexicalUnit value = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
    case MINUS:
      op = unaryOperator();
      break;
    default:
      jj_la1[89] = jj_gen;
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case EMS:
    case EXS:
    case LENGTH_PX:
    case LENGTH_CM:
    case LENGTH_MM:
    case LENGTH_IN:
    case LENGTH_PT:
    case LENGTH_PC:
    case ANGLE_DEG:
    case ANGLE_RAD:
    case ANGLE_GRAD:
    case TIME_MS:
    case TIME_S:
    case FREQ_HZ:
    case FREQ_KHZ:
    case PERCENTAGE:
    case NUMBER:
    case FUNCTION:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NUMBER:
        t = jj_consume_token(NUMBER);
                              value = LexicalUnitImpl.createNumber(prev, value(op, t.image));
        break;
      case PERCENTAGE:
        t = jj_consume_token(PERCENTAGE);
                              value = LexicalUnitImpl.createPercentage(prev, value(op, t.image));
        break;
      case LENGTH_PX:
        t = jj_consume_token(LENGTH_PX);
                              value = LexicalUnitImpl.createPixel(prev, value(op, t.image));
        break;
      case LENGTH_CM:
        t = jj_consume_token(LENGTH_CM);
                              value = LexicalUnitImpl.createCentimeter(prev, value(op, t.image));
        break;
      case LENGTH_MM:
        t = jj_consume_token(LENGTH_MM);
                              value = LexicalUnitImpl.createMillimeter(prev, value(op, t.image));
        break;
      case LENGTH_IN:
        t = jj_consume_token(LENGTH_IN);
                              value = LexicalUnitImpl.createInch(prev, value(op, t.image));
        break;
      case LENGTH_PT:
        t = jj_consume_token(LENGTH_PT);
                              value = LexicalUnitImpl.createPoint(prev, value(op, t.image));
        break;
      case LENGTH_PC:
        t = jj_consume_token(LENGTH_PC);
                              value = LexicalUnitImpl.createPica(prev, value(op, t.image));
        break;
      case EMS:
        t = jj_consume_token(EMS);
                              value = LexicalUnitImpl.createEm(prev, value(op, t.image));
        break;
      case EXS:
        t = jj_consume_token(EXS);
                              value = LexicalUnitImpl.createEx(prev, value(op, t.image));
        break;
      case ANGLE_DEG:
        t = jj_consume_token(ANGLE_DEG);
                              value = LexicalUnitImpl.createDegree(prev, value(op, t.image));
        break;
      case ANGLE_RAD:
        t = jj_consume_token(ANGLE_RAD);
                              value = LexicalUnitImpl.createRadian(prev, value(op, t.image));
        break;
      case ANGLE_GRAD:
        t = jj_consume_token(ANGLE_GRAD);
                              value = LexicalUnitImpl.createGradian(prev, value(op, t.image));
        break;
      case TIME_MS:
        t = jj_consume_token(TIME_MS);
                              value = LexicalUnitImpl.createMillisecond(prev, value(op, t.image));
        break;
      case TIME_S:
        t = jj_consume_token(TIME_S);
                              value = LexicalUnitImpl.createSecond(prev, value(op, t.image));
        break;
      case FREQ_HZ:
        t = jj_consume_token(FREQ_HZ);
                              value = LexicalUnitImpl.createHertz(prev, value(op, t.image));
        break;
      case FREQ_KHZ:
        t = jj_consume_token(FREQ_KHZ);
                              value = LexicalUnitImpl.createKiloHertz(prev, value(op, t.image));
        break;
      case FUNCTION:
        value = function(prev);
        break;
      default:
        jj_la1[90] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    case STRING:
      t = jj_consume_token(STRING);
                              value = new LexicalUnitImpl(prev, LexicalUnit.SAC_STRING_VALUE, t.image);
      break;
    case IDENT:
      t = jj_consume_token(IDENT);
                              value = new LexicalUnitImpl(prev, LexicalUnit.SAC_IDENT, t.image);
      break;
    case URI:
      t = jj_consume_token(URI);
                              value = new LexicalUnitImpl(prev, LexicalUnit.SAC_URI, t.image);
      break;
    case UNICODERANGE:
      t = jj_consume_token(UNICODERANGE);
                              value = new LexicalUnitImpl(prev, LexicalUnit.SAC_UNICODERANGE, t.image);
      break;
    case RGB:
      value = rgb(prev);
      break;
    case HASH:
      value = hexcolor(prev);
      break;
    case DIMEN:
      t = jj_consume_token(DIMEN);
        int n = getLastNumPos(t.image);
        value = LexicalUnitImpl.createDimension(
            prev,
            value(op, t.image.substring(0, n+1)),
            t.image.substring(n+1));
      break;
    case INHERIT:
      t = jj_consume_token(INHERIT);
                              value = new LexicalUnitImpl(prev, LexicalUnit.SAC_INHERIT, t.image);
      break;
    default:
      jj_la1[91] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    label_55:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case S:
        ;
        break;
      default:
        jj_la1[92] = jj_gen;
        break label_55;
      }
      jj_consume_token(S);
    }
      {if (true) return value;}
    throw new Error("Missing return statement in function");
  }

//
// function
//   : FUNCTION S* expr ')' S*
//   ;
//
  final public LexicalUnit function(LexicalUnit prev) throws ParseException {
    Token t;
    LexicalUnit params;
    t = jj_consume_token(FUNCTION);
    label_56:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case S:
        ;
        break;
      default:
        jj_la1[93] = jj_gen;
        break label_56;
      }
      jj_consume_token(S);
    }
    params = expr();
    jj_consume_token(RROUND);
        if (t.image.equalsIgnoreCase("counter(")) {
           {if (true) return LexicalUnitImpl.createCounter(prev, params);}
        } else if (t.image.equalsIgnoreCase("counters(")) {
           {if (true) return LexicalUnitImpl.createCounters(prev, params);}
        } else if (t.image.equalsIgnoreCase("attr(")) {
           {if (true) return LexicalUnitImpl.createAttr(prev, params);}
        } else if (t.image.equalsIgnoreCase("rect(")) {
           {if (true) return LexicalUnitImpl.createRect(prev, params);}
        }
        {if (true) return LexicalUnitImpl.createFunction(
            prev,
            t.image.substring(0, t.image.length() - 1),
            params);}
    throw new Error("Missing return statement in function");
  }

//
// rgb
//   : RGB S* expr ')' S*
//   ;
//
  final public LexicalUnit rgb(LexicalUnit prev) throws ParseException {
    Token t;
    LexicalUnit params;
    t = jj_consume_token(RGB);
    label_57:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case S:
        ;
        break;
      default:
        jj_la1[94] = jj_gen;
        break label_57;
      }
      jj_consume_token(S);
    }
    params = expr();
    jj_consume_token(RROUND);
        {if (true) return LexicalUnitImpl.createRgbColor(prev, params);}
    throw new Error("Missing return statement in function");
  }

//
// hexcolor
//   : HASH S*
//   ;
//
  final public LexicalUnit hexcolor(LexicalUnit prev) throws ParseException {
    Token t;
    t = jj_consume_token(HASH);
        // Step past the hash at the beginning
        int i = 1;
        int r = 0;
        int g = 0;
        int b = 0;
        int len = t.image.length() - 1;