miscmodule.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 1,774 行 · 第 1/3 页

    }
    
    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      Value arg;

      if (i < args.length) {
	arg = args[i];
	i++;
      }
      else {
	env.warning("a: not enough arguments");

	return i;
      }

      StringValue s = arg.toStringValue();

      int strlen = s.length();

      if (_length == Integer.MAX_VALUE) {
      }
      else if (strlen < _length) {
	env.warning("not enough characters in hex string");

	return i;
      }
      else if (_length < strlen)
	strlen = _length;
      
      int tail = strlen / 2;
      for (int j = 0; j < tail; j++) {
	int d = 0;
	
	char ch = s.charAt(2 * j);

	d += 16 * hexToDigit(env, ch);
	
	ch = s.charAt(2 * j + 1);

	d += hexToDigit(env, ch);

	bb.appendByte(d);
      }
      
      if ((strlen & 1) == 1) {
	int d = 16 * hexToDigit(env, s.charAt(strlen - 1));

	bb.appendByte(d);
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      StringValue sb = new StringBuilderValue();
      for (int i = _length / 2 - 1; i >= 0; i--) {
	int ch = is.read();

	sb.append(digitToHex(ch >> 4));
	sb.append(digitToHex(ch));
      }

      result.put(_name, sb);
    }
  }

  static class RevHexPackSegment extends PackSegment {
    private final StringValue _name;
    private final int _length;

    RevHexPackSegment(int length)
    {
      this("", length);
    }

    RevHexPackSegment(String name, int length)
    {
      _name = new StringBuilderValue(name);
      _length = length;
    }
    
    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      Value arg;

      if (i < args.length) {
	arg = args[i];
	i++;
      }
      else {
	env.warning("a: not enough arguments");

	return i;
      }

      StringValue s = arg.toStringValue();

      int strlen = s.length();

      if (_length == Integer.MAX_VALUE) {
      }
      else if (strlen < _length) {
	env.warning("not enough characters in hex string");

	return i;
      }
      else if (_length < strlen)
	strlen = _length;
      
      int tail = strlen / 2;
      for (int j = 0; j < tail; j++) {
	int d = 0;
	
	char ch = s.charAt(2 * j);

	d += hexToDigit(env, ch);
	
	ch = s.charAt(2 * j + 1);

	d += 16 * hexToDigit(env, ch);

	bb.appendByte(d);
      }
      
      if ((strlen & 1) == 1) {
	int d = hexToDigit(env, s.charAt(strlen - 1));

	bb.appendByte(d);
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      StringValue sb = new StringBuilderValue();
      for (int i = _length / 2 - 1; i >= 0; i--) {
	int ch = is.read();

	sb.append(digitToHex(ch));
	sb.append(digitToHex(ch >> 4));
      }

      result.put(_name, sb);
    }
  }

  static class BigEndianPackSegment extends PackSegment {
    private final String _name;
    private final int _length;
    private final int _bytes;
    private final boolean _isSigned;

    BigEndianPackSegment(int length, int bytes)
    {
      _name = "";
      _length = length;
      _bytes = bytes;
      _isSigned = false;
    }

    BigEndianPackSegment(String name, int length, int bytes, boolean isSigned)
    {
      _name = name;
      _length = length;
      _bytes = bytes;
      _isSigned = isSigned;
    }
    
    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value arg;

	if (i < args.length) {
	  arg = args[i];
	  i++;
	}
	else if (_length == Integer.MAX_VALUE)
	  return i;
	else {
	  env.warning("a: not enough arguments");

	  return i;
	}
 
	long v = arg.toLong();

	for (int k = _bytes - 1; k >= 0; k--) {
	  bb.appendByte((int) (v >> (8 * k)));
	}
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value key;

	// XXX: check key type with unicode semantics

	if (_name.length() == 0)
	  key = LongValue.create(j + 1);
	else if (_length == 1)
	  key = new StringBuilderValue(_name);
	else {
	  StringValue sb = new StringBuilderValue();
	  sb.append(_name);
	  sb.append(j);

	  key = sb;
	}
	
	long v = 0;

	for (int k = 0; k < _bytes; k++) {
	  long d = is.read() & 0xff;
	  
	  v = (v << 8) + d;
	}

	if (_isSigned) {
	  switch (_bytes) {
	  case 1:
	    v = (byte) v;
	    break;
	  case 2:
	    v = (short) v;
	    break;
	  case 4:
	    v = (int) v;
	    break;
	  }
	}

	result.put(key, LongValue.create(v));
      }
    }
  }

  static class LittleEndianPackSegment extends PackSegment {
    private final String _name;
    private final int _length;
    private final int _bytes;

    LittleEndianPackSegment(int length, int bytes)
    {
      _name = "";
      _length = length;
      _bytes = bytes;
    }

    LittleEndianPackSegment(String name, int length, int bytes)
    {
      _name = name;
      _length = length;
      _bytes = bytes;
    }
    
    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value arg;

	if (i < args.length) {
	  arg = args[i];
	  i++;
	}
	else if (_length == Integer.MAX_VALUE)
	  return i;
	else {
	  env.warning("a: not enough arguments");

	  return i;
	}
 
	long v = arg.toLong();

	for (int k = 0; k < _bytes; k++) {
	  bb.appendByte((int) (v >> (8 * k)));
	}
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value key;

	if (_name == "")
	  key = LongValue.create(j);
	else if (_length == 1)
	  key = new StringBuilderValue(_name);
	else {
	  StringBuilderValue sb = new StringBuilderValue();
	  sb.append(_name);
	  sb.append(j);

	  key = sb;
	}
	
	long v = 0;

	for (int k = 0; k < _bytes; k++) {
	  long d = is.read() & 0xff;

	  v |= d << 8 * k;
	}

	result.put(key, LongValue.create(v));
      }
    }
  }

  static class DoublePackSegment extends PackSegment {
    private final String _name;
    private final int _length;

    DoublePackSegment(int length)
    {
      this("", length);
    }

    DoublePackSegment(String name, int length)
    {
      _name = name;
      _length = length;
    }
    
    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value arg;

	if (i < args.length) {
	  arg = args[i];
	  i++;
	}
	else if (_length == Integer.MAX_VALUE)
	  return i;
	else {
	  env.warning("a: not enough arguments");

	  return i;
	}
 
	double d = arg.toDouble();
	long v = Double.doubleToLongBits(d);

	for (int k = 7; k >= 0; k--) {
	  bb.appendByte((int) (v >> (8 * k)));
	}
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value key;

	if (_name == "")
	  key = LongValue.create(j);
	else if (_length == 1)
	  key = env.createString(_name);
	else {
	  StringValue sb = env.createBinaryBuilder();
	  sb.append(_name);
	  sb.append(j);

	  key = sb;
	}
	
	long v = 0;

	for (int k = 0; k < 8; k++) {
	  long d = is.read() & 0xff;

	  v = 256 * v + d;
	}

	result.put(key, new DoubleValue(Double.longBitsToDouble(v)));
      }
    }
  }

  static class FloatPackSegment extends PackSegment {
    private final String _name;
    private final int _length;

    FloatPackSegment(int length)
    {
      this("", length);
    }

    FloatPackSegment(String name, int length)
    {
      _name = name;
      _length = length;
    }

    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value arg;

	if (i < args.length) {
	  arg = args[i];
	  i++;
	}
	else if (_length == Integer.MAX_VALUE)
	  return i;
	else {
	  env.warning("a: not enough arguments");

	  return i;
	}
 
	double d = arg.toDouble();
	int v = Float.floatToIntBits((float) d);

	for (int k = 3; k >= 0; k--) {
	  bb.appendByte((int) (v >> (8 * k)));
	}
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	Value key;

	if (_name == "")
	  key = LongValue.create(j);
	else if (_length == 1)
	  key = env.createString(_name);
	else {
	  StringValue sb = env.createBinaryBuilder();
	  sb.append(_name);
	  sb.append(j);

	  key = sb;
	}
	
	int v = 0;

	for (int k = 0; k < 4; k++) {
	  int d = is.read() & 0xff;

	  v = 256 * v + d;
	}

	result.put(key, new DoubleValue(Float.intBitsToFloat(v)));
      }
    }
  }

  static class NullPackSegment extends PackSegment {
    private final String _name;
    private final int _length;

    NullPackSegment(int length)
    {
      this("", length);
    }

    NullPackSegment(String name, int length)
    {
      _name = name;
      
      if (length == Integer.MAX_VALUE)
	length = 0;
      
      _length = length;
    }
    
    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      for (int j = 0; j < _length; j++) {
	bb.appendByte(0);
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      for (int i = 0; i < _length; i++)
	is.read();
    }
  }

  static class PositionPackSegment extends PackSegment {
    private final int _length;

    PositionPackSegment(int length)
    {
      this("", length);
    }

    PositionPackSegment(String name, int length)
    {
      if (length == Integer.MAX_VALUE)
	length = 0;
      
      _length = length;
    }
    
    @Override
    public int pack(Env env, StringValue bb, int i, Value []args)
      throws IOException
    {
      while (bb.length() < _length) {
	bb.appendByte(0);
      }

      return i;
    }
    
    @Override
    public void unpack(Env env, ArrayValue result, InputStream is)
      throws IOException
    {
      throw new UnsupportedOperationException("'@' skip to position");
    }
  }

  static int hexToDigit(Env env, char ch)
  {
    if ('0' <= ch && ch <= '9')
      return (ch - '0');
    else if ('a' <= ch && ch <= 'f')
      return (ch - 'a' + 10);
    else if ('A' <= ch && ch <= 'F')
      return (ch - 'A' + 10);
    else {
      env.warning("pack: non hex digit: " + (char) ch);

      return 0;
    }
  }

  static char digitToHex(int d)
  {
    d &= 0xf;
    
    if (d < 10)
      return (char) ('0' + d);
    else
      return (char) ('a' + d - 10);
  }
}