Beispiel #1
0
 @Override
 public ParseTree optimizeDynamic(Target t, List<ParseTree> children, FileOptions fileOptions)
     throws ConfigCompileException, ConfigRuntimeException {
   // We can check 2 things here, one, that the statement isn't dynamic, and if not, then
   // 2, that the parameter count matches the ? count. No checks can be done for typing,
   // without making a connection to the db though, so we won't do that here.
   Construct queryData = children.get(1).getData();
   if (queryData instanceof CFunction) {
     // If it's a concat or sconcat, warn them that this is bad
     if ("sconcat".equals(queryData.val()) || "concat".equals(queryData.val())) {
       CHLog.GetLogger()
           .w(
               CHLog.Tags.COMPILER,
               "Use of concatenated query detected! This"
                   + " is very bad practice, and could lead to SQL injection vulnerabilities"
                   + " in your code. It is highly recommended that you use prepared queries,"
                   + " which ensure that your parameters are properly escaped.",
               t);
     }
   } else if (queryData instanceof CString) {
     // It's a hard coded query, so we can double check parameter lengths
     int count = 0;
     for (char c : queryData.val().toCharArray()) {
       if (c == '?') {
         count++;
       }
     }
     // -2 accounts for the profile data and query
     if (children.size() - 2 != count) {
       throw new ConfigCompileException(
           StringUtils.PluralTemplateHelper(
                   count, "%d parameter token was", "%d parameter tokens were")
               + " found in the query, but "
               + StringUtils.PluralTemplateHelper(
                   children.size() - 2, "%d parameter was", "%d parameters were")
               + " provided to query().",
           t);
     }
   }
   return null;
 }
 @Override
 public ParseTree optimizeDynamic(Target t, List<ParseTree> children, FileOptions fileOptions)
     throws ConfigCompileException, ConfigRuntimeException {
   if (children.size() < 5) {
     throw new ConfigRuntimeException(
         "bind accepts 5 or more parameters", ExceptionType.InsufficientArgumentsException, t);
   }
   if (!children.get(0).isConst()) {
     // This ability may be removed in the future, to allow for better compilation checks of
     // event type, once objects are added.
     // We'll add this warning to gauge impact.
     CHLog.GetLogger()
         .Log(
             CHLog.Tags.COMPILER,
             LogLevel.WARNING,
             "Use of dynamic bind. This may be removed in the future, please"
                 + " contact the developers to provide feedback if this affects you.",
             t);
   }
   return null;
 }
  public static void main(String[] args) throws Exception {
    try {
      // Boilerplate startup stuff
      Implementation.setServerType(Implementation.Type.BUKKIT);
      ClassDiscovery.getDefaultInstance()
          .addDiscoveryLocation(ClassDiscovery.GetClassContainer(DocGen.class));
      ExtensionManager.Initialize(ClassDiscovery.getDefaultInstance());
      Installer.Install(CommandHelperFileLocations.getDefault().getConfigDirectory());
      Prefs.init(CommandHelperFileLocations.getDefault().getPreferencesFile());
      CHLog.initialize(CommandHelperFileLocations.getDefault().getConfigDirectory());

      // System.out.println(functions("wiki", api.Platforms.INTERPRETER_JAVA, true));
      System.out.println(examples("if", true));
      // System.exit(0);
      // events("wiki");
      // System.out.println(Template("persistence_network"));
    } catch (Throwable t) {
      t.printStackTrace();
      System.exit(1);
    } finally {
      System.exit(0);
    }
  }
Beispiel #4
0
  public void sort(final SortType sort) {
    List<Construct> list = array;
    if (this.associative_mode) {
      list = new ArrayList(associative_array.values());
      this.associative_array.clear();
      this.associative_array = null;
      this.associative_mode = false;
      CHLog.GetLogger()
          .Log(
              CHLog.Tags.GENERAL,
              LogLevel.VERBOSE,
              "Attempting to sort an associative array; key values will be lost.",
              this.getTarget());
    }
    Collections.sort(
        array,
        new Comparator<Construct>() {
          @Override
          public int compare(Construct o1, Construct o2) {
            // o1 < o2 -> -1
            // o1 == o2 -> 0
            // o1 > o2 -> 1
            for (int i = 0; i < 2; i++) {
              Construct c;
              if (i == 0) {
                c = o1;
              } else {
                c = o2;
              }
              if (c instanceof CArray) {
                throw ConfigRuntimeException.BuildException(
                    "Cannot sort an array of arrays.",
                    ExceptionType.CastException,
                    CArray.this.getTarget());
              }
              if (!(c instanceof CBoolean
                  || c instanceof CString
                  || c instanceof CInt
                  || c instanceof CDouble
                  || c instanceof CNull)) {
                throw ConfigRuntimeException.BuildException(
                    "Unsupported type being sorted: " + c.getCType(),
                    ExceptionType.FormatException,
                    CArray.this.getTarget());
              }
            }
            if (o1 instanceof CNull || o2 instanceof CNull) {
              if (o1 instanceof CNull && o2 instanceof CNull) {
                return 0;
              } else if (o1 instanceof CNull) {
                return "".compareTo(o2.getValue());
              } else {
                return o1.val().compareTo("");
              }
            }
            if (o1 instanceof CBoolean || o2 instanceof CBoolean) {
              if (Static.getBoolean(o1) == Static.getBoolean(o2)) {
                return 0;
              } else {
                int oo1 = Static.getBoolean(o1) == true ? 1 : 0;
                int oo2 = Static.getBoolean(o2) == true ? 1 : 0;
                return (oo1 < oo2) ? -1 : 1;
              }
            }
            // At this point, things will either be numbers or strings
            switch (sort) {
              case REGULAR:
                return compareRegular(o1, o2);
              case NUMERIC:
                return compareNumeric(o1, o2);
              case STRING:
                return compareString(o1.val(), o2.val());
              case STRING_IC:
                return compareString(o1.val().toLowerCase(), o2.val().toLowerCase());
            }
            throw ConfigRuntimeException.CreateUncatchableException(
                "Missing implementation for " + sort.name(), Target.UNKNOWN);
          }

          public int compareRegular(Construct o1, Construct o2) {
            if (Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1))
                && Static.getBoolean(
                    new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2))) {
              return compareNumeric(o1, o2);
            } else if (Static.getBoolean(
                new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1))) {
              // The first is a number, the second is a string
              return -1;
            } else if (Static.getBoolean(
                new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2))) {
              // The second is a number, the first is a string
              return 1;
            } else {
              // They are both strings
              return compareString(o1.val(), o2.val());
            }
          }

          public int compareNumeric(Construct o1, Construct o2) {
            double d1 = Static.getNumber(o1, o1.getTarget());
            double d2 = Static.getNumber(o2, o2.getTarget());
            return Double.compare(d1, d2);
          }

          public int compareString(String o1, String o2) {
            return o1.compareTo(o2);
          }
        });
    this.array = list;
    this.regenValue(new HashSet<CArray>());
  }