xquery.java

A framework written in Java for implementing high-level and dynamic languages, compiling them into J

                  "secondsFromTime");
    define_method("timezone-from-time", "gnu.xquery.util.TimeUtils",
                  "timezoneFromTime");
    define_method("adjust-dateTime-to-timezone", "gnu.xquery.util.TimeUtils",
                  "adjustDateTimeToTimezone"); // overloaded
    define_method("adjust-date-to-timezone", "gnu.xquery.util.TimeUtils",
                  "adjustDateToTimezone"); // overloaded
    define_method("adjust-time-to-timezone", "gnu.xquery.util.TimeUtils",
                  "adjustTimeToTimezone"); // overloaded
    define_method("dateTime", "gnu.xquery.util.TimeUtils", "dateTime");
    define_method("current-dateTime", "gnu.xquery.util.TimeUtils",
                  "currentDateTime");
    define_method("current-date", "gnu.xquery.util.TimeUtils",
                  "currentDate");
    define_method("current-time", "gnu.xquery.util.TimeUtils",
                  "currentTime");
    define_method("implicit-timezone", "gnu.xquery.util.TimeUtils",
                  "implicitTimezone");

    define_method("zero-or-one", "gnu.xquery.util.SequenceUtils", "zeroOrOne");
    define_method("one-or-more", "gnu.xquery.util.SequenceUtils", "oneOrMore");
    define_method("exactly-one", "gnu.xquery.util.SequenceUtils", "exactlyOne");

    defProcStFld("distinct-nodes", "gnu.kawa.xml.SortNodes", "sortNodes");

    // FIXME - should be imported?
    defProcStFld("children", "gnu.kawa.xml.Children", "children");
    define_method("not", "gnu.xquery.util.BooleanValue", "not");

    defaultNamespace = qexoFunctionNamespace;
    defProcStFld("response-header", "gnu.kawa.servlet.HTTP");
    defProcStFld("response-content-type", "gnu.kawa.servlet.HTTP");
    defProcStFld("response-status", "gnu.kawa.servlet.HTTP");
    defProcStFld("error-response", "gnu.kawa.servlet.HTTP");
    defProcStFld("current-servlet", "gnu.kawa.servlet.HTTP");
    defProcStFld("current-servlet-context", "gnu.kawa.servlet.HTTP");
    defProcStFld("current-servlet-config", "gnu.kawa.servlet.HTTP");
    defProcStFld("servlet-context-realpath", "gnu.kawa.servlet.HTTP");
    defProcStFld("get-response", "gnu.kawa.servlet.HTTP");
    defProcStFld("get-request", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-method", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-uri", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-url", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-path-info", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-path-translated", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-servlet-path", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-query-string", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-parameter", "gnu.kawa.servlet.HTTP");
    defProcStFld("request-parameters", "gnu.kawa.servlet.HTTP");
    defaultNamespace = xqueryFunctionNamespace;
  }

  public static XQuery getInstance()
  {
    return instance;
  }

  /** The compiler insert calls to this method for applications and applets. */
  public static void registerEnvironment()
  {
    Language.setDefaults(instance);
  }

  static public QuoteExp falseExp =
    new QuoteExp(Boolean.FALSE, XDataType.booleanType);
  static public QuoteExp trueExp =
    new QuoteExp(Boolean.TRUE, XDataType.booleanType);

  public static final ConstantFunction0 falseFunction
    = new ConstantFunction0("false", falseExp);
  public static final ConstantFunction0 trueFunction
    = new ConstantFunction0("true", trueExp);

  public Consumer getOutputConsumer(java.io.Writer out)
  {
    return new XMLPrinter(out, false);
  }

  static Object[] typeMap =
    { "string", XDataType.stringType,
      "untypedAtomic", XDataType.untypedAtomicType,
      "boolean", XDataType.booleanType,
      "integer", XIntegerType.integerType,
      "long", XIntegerType.longType,
      "int", XIntegerType.intType,
      "short", XIntegerType.shortType,
      "byte", XIntegerType.byteType,
      "unsignedLong", XIntegerType.unsignedLongType,
      "unsignedInt", XIntegerType.unsignedIntType,
      "unsignedShort", XIntegerType.unsignedShortType,
      "unsignedByte", XIntegerType.unsignedByteType,
      "positiveInteger", XIntegerType.positiveIntegerType,
      "nonPositiveInteger", XIntegerType.nonPositiveIntegerType,
      "negativeInteger", XIntegerType.negativeIntegerType,
      "nonNegativeInteger", XIntegerType.nonNegativeIntegerType,
      "date", XTimeType.dateType,
      "dateTime", XTimeType.dateTimeType,
      "time", XTimeType.timeType,
      "duration", XTimeType.durationType,
      "yearMonthDuration", XTimeType.yearMonthDurationType,
      "dayTimeDuration", XTimeType.dayTimeDurationType,
      "gYearMonth", XTimeType.gYearMonthType,
      "gYear", XTimeType.gYearType,
      "gMonthDay", XTimeType.gMonthDayType,
      "gDay", XTimeType.gDayType,
      "gMonth", XTimeType.gMonthType,
      "decimal", XDataType.decimalType,
      "float", XDataType.floatType,
      "double", XDataType.doubleType,
      "anyURI", XDataType.anyURIType,
      "hexBinary", XDataType.hexBinaryType,
      "base64Binary", XDataType.base64BinaryType,
      "NOTATION", XDataType.NotationType,
      "QName", "gnu.mapping.Symbol",
      "normalizedString", XStringType.normalizedStringType,
      "token", XStringType.tokenType,
      "language", XStringType.languageType,
      "NMTOKEN", XStringType.NMTOKENType,
      "Name", XStringType.NameType,
      "NCName", XStringType.NCNameType,
      "ID", XStringType.IDType,
      "IDREF", XStringType.IDREFType,
      "ENTITY", XStringType.ENTITYType,
      "anyAtomicType", XDataType.anyAtomicType
    };

  public static Type getStandardType (String name)
  {
    for (int i = typeMap.length;  (i -= 2) >= 0; )
      {
	if (typeMap[i].equals(name))
	  {
	    Object t = typeMap[i+1];
	    if (t instanceof String)
	      return Scheme.string2Type((String) t);
	    else
	      return (Type) t;
	  }
      }
    return null;
  }

  public Type getTypeFor(String name)
  {
    String core = name.startsWith("xs:") ? name.substring(3)
      : name.startsWith("xdt:") ? name.substring(4)
      : name;
    Type t = getStandardType(core);
    return t != null ? t : Scheme.string2Type(name);
  }

  public String formatType (Type type)
  {
    String tname = type.getName();
    if ("gnu.math.IntNum".equals(tname))
      return "xs:integer";
    if ("java.lang.String".equals(tname)
        || "java.lang.CharSequence".equals(tname))
      return "xs:string";
    return type.toString();
  }

  public Type getTypeFor (Class clas)
  {
    if (clas.isPrimitive())
      {
	String name = clas.getName();
	if (name.equals("boolean"))
          return XDataType.booleanType;
	return Scheme.getNamedType(name);
      }
    else if (! clas.isArray())
      {
        String name = clas.getName();
        if (name.equals("java.lang.String"))
          return XDataType.stringStringType;
        if (name.equals("gnu.kawa.xml.UntypedAtomic"))
          return XDataType.untypedAtomicType;
        if (name.equals("java.lang.Boolean"))
          return XDataType.booleanType;
        if (name.equals("java.lang.Float"))
          return XDataType.floatType;
        if (name.equals("java.lang.Double"))
          return XDataType.doubleType;
        if (name.equals("java.math.BigDecimal"))
          return XDataType.decimalType;
        if (name.equals("gnu.math.Duration"))
          return XDataType.durationType;
        if (name.equals("gnu.text.Path"))
          return  XDataType.anyURIType;
      }
    return Type.make(clas);
  }

  public Procedure getPrompter()
  {
    return new Prompter();
  }

  /*
  static boolean isPunctuation (char ch)
  {
    return ch == '-' || ch == '.' || ch == ':' || ch == '_'
      || (ch >= 0xB7 // To short-circuit rare tests
	  && (ch == '\u00B7' // middle dot
	      || ch == '\u0387' // greek ano teleia
	      || ch == '\u06dd' // arabic end of ayah
	      || ch == '\u06de' // arabic start of rub el hizb
	      ));
  }

  static boolean isMark (char ch)
  {
    return ! Character.isLetter(ch)
      && ! Characfter.isDigit(ch)
      && Character.isJavaIdnteiferiPart(ch);
  }
  */

  /** Mangle an XML name as specified by JAXB. */
  static void mangle (String name, int start, int length,
		      StringBuffer sbuf, char mode)
  {
    // One of 'P' for punctuation; 'D' for digit;  'M' for mark;
    // 'L' for lower-case; 'U' for upper-case; 'O' other (uncased) letter.
    char prev = 'P';
    int outStart = sbuf.length();
    for (int i = 0;  i < length;  )
      {
	boolean wordStart;
	char ch = name.charAt(start + i);
	i++;
	if (Character.isUpperCase(ch))
	  {
	    wordStart = prev != 'U'
	      || (i < length
		  && Character.isLowerCase(name.charAt(start+i)));
	    prev = 'U';
	  }
	else if (Character.isLowerCase(ch))
	  {
	    wordStart = prev != 'L' || prev != 'U';
	    prev = 'L';
	  }
	else if (Character.isLetter(ch))
	  { // uncased letter
	    wordStart = prev != 'O';
	    prev = 'O';
	  }
	else if (Character.isDigit(ch))
	  {
	    wordStart = prev != 'D';
	    prev = 'D';
	  }
	else if (Character.isJavaIdentifierPart(ch))
	  {
	    wordStart = prev != 'D' && prev != 'M';
	    prev = 'M';
	  }
	else // if (isPunctuation(ch))
	  {
	    prev = 'P';
	    continue;
	  }
	if (wordStart || mode == '_')
	  {
	    if (wordStart && mode == '_' && sbuf.length() > outStart)
	      sbuf.append('_');
	    ch = Character.toUpperCase(ch);
	  }
	sbuf.append(ch);
      }
  }
  public static String mangle (String name)
  {
    StringBuffer sbuf = new StringBuffer();
    mangle(name, 0, name.length(), sbuf, 'U');
    return sbuf.toString();
  }

  public static String makeClassName (String source)
  {
    source = source.replace(java.io.File.separatorChar, '/');
    int sl = source.lastIndexOf('/');
    if (sl >= 0)
      source = source.substring(sl+1);
    int dot = source.lastIndexOf('.');
    if (dot >= 0)
      source = source.substring(0, dot);
    return Compilation.mangleNameIfNeeded(source);
  }

  public static Object getExternal (Symbol name, Object type)
  {
    Environment env = Environment.getCurrent();
    Object value = env.get(name, null, null);
    if (value == null)
      value = env.get(Symbol.makeWithUnknownNamespace(name.getLocalName(),
                                                      name.getPrefix()),
                      null, null);
    if (value == null)
      throw new RuntimeException("unbound external "+name);
    if (type == null)
      return value;
    if (type instanceof XDataType)
      return ((XDataType) type).cast(value);
    if (type instanceof ClassType)
      {
        String cname = ((ClassType) type).getName();
        // KLUDGE - FIXME
        if ("gnu.math.IntNum".equals(cname))
          return IntNum.valueOf(value.toString());
        if ("gnu.math.RealNum".equals(cname))
          return gnu.math.DFloNum.make(Double.parseDouble(value.toString()));
      }
    try
      {
        value = ((Type) type).coerceFromObject(value);
      }
    catch (ClassCastException ex)
      {
        throw new WrongType(name.toString(),
                            WrongType.ARG_VARNAME,
                            value,
                            type.toString());
      }
    return value;
  }
}

class Prompter extends Procedure1
{
  public Object apply1 (Object arg)
  {
    InPort port = (InPort) arg;
    int line = port.getLineNumber() + 1;
    char state = port.readState;
    if (state == '\n')
      state = ' ';
    if (state == '<')
      return "<!--" + line + "-->";
    else if (state == ':')
      return "-(:" + line + "c:) ";
    else
      return "(: " + line + state + ":) ";
  }
}