acdfunresolve.java

emboss的linux版本的源代码

          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    rec = new RECompiler();           // float == float
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t]*[=][=]" +
                                     "[ \t]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        double da = (new Double(regexp.getParen(1))).doubleValue();
        double db = (new Double(regexp.getParen(2))).doubleValue();
        if(da==db)
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    rec = new RECompiler();           // string == string
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([a-zA-Z]+[a-zA-Z0-9]*)[ \t]*[=][=]" +
                                     "[ \t]*([a-zA-Z]+[a-zA-Z0-9]*)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        String sa = regexp.getParen(1);
        String sb = regexp.getParen(2);
        if(sa.equalsIgnoreCase(sb))
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    return false;
  }

  /** 
  *
  * Looks for and resolves an expression <code>@( num != num )</code>
  * @param exp 	String with possible expression
  * @return 	true if successfully resolved
  *
  */
  private boolean acdExpNotEqual(String exp)
  {

    RECompiler rec = new RECompiler();   // int != int
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([-+]*[:digit:]+)[ \t]*[!][=][ \t]*([-+]*[:digit:]+)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        int ia = (new Integer(regexp.getParen(1))).intValue();
        int ib = (new Integer(regexp.getParen(2))).intValue();
        if(ia!=ib)
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    rec = new RECompiler();           // float != float
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t]*[!][=]" +
                                     "[ \t]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        double da = (new Double(regexp.getParen(1))).doubleValue();
        double db = (new Double(regexp.getParen(2))).doubleValue();
        if(da!=db)
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    rec = new RECompiler();           // string != string
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([a-zA-Z]+[a-zA-Z0-9]*)[ \t]*[!][=]" +
                                     "[ \t]*([a-zA-Z]+[a-zA-Z0-9]*)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        String sa = regexp.getParen(1);
        String sb = regexp.getParen(2);
        if(!sa.equalsIgnoreCase(sb))
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    return false;
  }


  /** 
  *
  * Looks for and resolves an expression <code>@( num > num )</code>
  * @param exp 	String with possible expression
  * @return 	true if successfully resolved
  *
  */
  private boolean acdExpGreater(String exp)
  {

    RECompiler rec = new RECompiler();   // int > int
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([-+]*[:digit:]+)[ \t]*[>][ \t]*([-+]*[:digit:]+)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        int ia = (new Integer(regexp.getParen(1))).intValue();
        int ib = (new Integer(regexp.getParen(2))).intValue();
        if(ia>ib)
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    rec = new RECompiler();           // float > float
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t]*[>]" +
                                     "[ \t]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        double da = (new Double(regexp.getParen(1))).doubleValue();
        double db = (new Double(regexp.getParen(2))).doubleValue();
        if(da>db)
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    return false;
  }



  /** 
  *
  * Looks for and resolves an expression <code>@( num < num )</code>
  * @param exp 	String with possible expression
  * @return 	true if successfully resolved
  *
  */
  private boolean acdExpLesser(String exp)
  {

    RECompiler rec = new RECompiler();   // int < int
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([-+]*[:digit:]+)[ \t]*[<][ \t]*([-+]*[:digit:]+)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        int ia = (new Integer(regexp.getParen(1))).intValue();
        int ib = (new Integer(regexp.getParen(2))).intValue();
        if(ia<ib)
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    rec = new RECompiler();           // float < float
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t]*[<]" +
                                     "[ \t]*([-+]*[:digit:]+[.]*[:digit:]*)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        double da = (new Double(regexp.getParen(1))).doubleValue();
        double db = (new Double(regexp.getParen(2))).doubleValue();
        if(da<db)
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    return false;
  }


  /** 
  *
  * Looks for and resolves an expression <code>@( num | num )</code>
  * @param exp 	String with possible expression
  * @return 	true if successfully resolved
  *
  */
  private boolean acdExpOr(String exp)
  {

    RECompiler rec = new RECompiler(); // string | string 
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([a-zA-Z]+)[ \t]*[|]" +
                                     "[ \t]*([a-zA-Z]+)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        String ba = regexp.getParen(1);
        String bb = regexp.getParen(2);
        if ( ba.equalsIgnoreCase("true") || bb.equalsIgnoreCase("true") )
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }


    return false;
  }


  /** 
  *
  * Looks for and resolves an expression <code>@( num & num )</code>
  * @param exp 	String with possible expression
  * @return 	true if successfully resolved
  *
  */
  private boolean acdExpAnd(String exp)
  {

    RECompiler rec = new RECompiler(); // string & string
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([a-zA-Z]+[a-zA-Z0-9]*)[ \t]*[&]" +
                                     "[ \t]*([a-zA-Z]+[a-zA-Z0-9]*)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        String ba = regexp.getParen(1);
        String bb = regexp.getParen(2);
        if ( ba.equalsIgnoreCase("true") && bb.equalsIgnoreCase("true") )
          result = "true";
        else
          result = "false";
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    return false;
  }
  

  /** 
  *
  * Looks for and resolves an expression <code>@( bool ? trueval : falseval )</code>
  * @param exp 	String with possible expression
  * @return 	true if successfully resolved
  *
  */
  private boolean acdExpCond(String exp)
  {

    RECompiler rec = new RECompiler(); 
    try
    {
      REProgram  rep = rec.compile("^[ \t(]*([a-zA-Z]+)[ \t]*[?]" +
                                    "[ \t]*([^: \t]+)[ \t]*(:)" +
                                    "[ \t]*([^: \t)]+)[ \t)]*$");
      RE regexp = new RE(rep);
      if(regexp.match(exp))
      {
        if(regexp.getParen(1).equalsIgnoreCase("true"))
          result = regexp.getParen(2);
        else
          result = regexp.getParen(4);
        return true;
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    return false;
  }


  /**  
  *
  * Looks for and resolves an expression as a switch/case statement
  * <code>@( var = casea : vala, caseb: valb else: val )</code>
  * @param exp 	String with possible expression
  * @return 	true if successfully resolved
  *
  */
  private boolean acdExpCase(String exp)
  {

    RECompiler rec = new RECompiler();
    try
    {
      REProgram caseexp = rec.compile("^[ \t]*([A-Za-z0-9]+)[ \t]*[=]");
      REProgram listexp = rec.compile("^[ \t]*([^: \t]+)[ \t]*[:]+" +
                                         "[ \t]*([^: \t,]+)[ \t,]*");

      RE caseregexp = new RE(caseexp);
      if(caseregexp.match(exp))
      {
      }
    }
    catch (RESyntaxException rese)
    {
      System.out.println("RESyntaxException ");
    }

    return false;
  }

}