Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • hammer/hammer
  • mlp/hammer
  • xentrac/hammer
  • pesco/hammer
  • letitiali/hammer
  • nobody/hammer
  • kia/hammer-sandbox
  • vyrus001/hammer
  • denleylam/hammer
9 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 620 additions and 11 deletions
jni/com/upstandinghackers/hammer/Parser.java → src/bindings/java/java/src/main/java/com/upstandinghackers/hammer/Parser.java
View file @ 26876183
......@@ -5,6 +5,15 @@ public class Parser
public native void bindIndirect(Parser inner);
public native void free();
public long getInner() {return this.inner;}
public ParseResult parse(String input) {
byte[] bytes = new byte[input.length()];
for (int i = 0; i < input.length(); i++)
bytes[i] = (byte)input.charAt(i);
return Hammer.parse(this, bytes, bytes.length);
}
public ParseResult parse(byte[] input, int length) {
return Hammer.parse(this, input, length);
}
private long inner;
Parser(long inner) {this.inner=inner;}
......
src/bindings/java/native/linux/pom.xml 0 → 100644
View file @ 26876183
<project>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.upstandinghackers</groupId>
<artifactId>native</artifactId>
<version>0.9</version>
</parent>
<groupId>com.upstandinghackers</groupId>
<artifactId>libhammer-java</artifactId>
<version>0.9</version>
<name>Hammer JNI Bindings - Linux Native</name>
<packaging>so</packaging>
<dependencies>
<dependency>
<groupId>com.upstandinghackers</groupId>
<artifactId>hammer-java</artifactId>
<version>0.9</version>
<type>jar</type>
</dependency>
</dependencies>
<build>
<testSourceDirectory>../src/test/java</testSourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>native-maven-plugin</artifactId>
<extensions>true</extensions>
<configuration>
<javahOS>linux</javahOS>
<javahSearchJNIFromDependencies>true</javahSearchJNIFromDependencies>
<compilerProvider>generic</compilerProvider>
<compilerStartOptions>
<compilerStartOption>-std=gnu99 -Wall -Wextra -Werror -Wno-unused-parameter -Wno-attributes -O3 -fPIC</compilerStartOption>
</compilerStartOptions>
<sources>
<source>
<directory>../src/main/native</directory>
<fileNames>
<fileName>com_upstandinghackers_hammer_Hammer.c</fileName>
<fileName>com_upstandinghackers_hammer_ParsedToken.c</fileName>
<fileName>com_upstandinghackers_hammer_Parser.c</fileName>
<fileName>com_upstandinghackers_hammer_ParseResult.c</fileName>
</fileNames>
</source>
</sources>
<linkerStartOptions>
<linkerStartOption>-shared -L../../../../ -lhammer</linkerStartOption>
</linkerStartOptions>
</configuration>
<executions>
<execution>
<id>javah</id>
<phase>generate-sources</phase>
<configuration>
<javahOS>linux</javahOS>
<javahProvider>default</javahProvider>
</configuration>
<goals>
<goal>javah</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<argLine>-Djava.library.path=${project.build.directory}</argLine>
<forkMode>once</forkMode>
<environmentVariables>
<LD_LIBRARY_PATH>${project.build.directory}:../../../../</LD_LIBRARY_PATH>
</environmentVariables>
</configuration>
</plugin>
</plugins>
</build>
</project>
src/bindings/java/native/pom.xml 0 → 100644
View file @ 26876183
<project>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.upstandinghackers</groupId>
<artifactId>hammer</artifactId>
<version>0.9</version>
</parent>
<groupId>com.upstandinghackers</groupId>
<artifactId>native</artifactId>
<version>0.9</version>
<name>Hammer JNI Bindings - Native</name>
<packaging>pom</packaging>
<profiles>
<profile>
<id>linux</id>
<activation>
<property>
<name>platform</name>
<value>linux</value>
</property>
</activation>
<modules>
<module>linux</module>
</modules>
</profile>
</profiles>
</project>
jni/com_upstandinghackers_hammer_Hammer.c → src/bindings/java/native/src/main/native/com_upstandinghackers_hammer_Hammer.c
View file @ 26876183
......@@ -94,28 +94,28 @@ JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_int8
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uInt64
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uint64
(JNIEnv *env, jclass class)
{
RETURNWRAP(env, h_uint64());
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uInt32
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uint32
(JNIEnv *env, jclass class)
{
RETURNWRAP(env, h_uint32());
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uInt16
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uint16
(JNIEnv *env, jclass class)
{
RETURNWRAP(env, h_uint16());
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uInt8
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_uint8
(JNIEnv *env, jclass class)
{
RETURNWRAP(env, h_uint8());
......@@ -157,6 +157,13 @@ JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_in
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_notIn
(JNIEnv *env, jclass class, jbyteArray charset, jint length)
{
RETURNWRAP(env, h_not_in((uint8_t*) ((*env)->GetByteArrayElements(env, charset, NULL)), (size_t)length));
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_endP
(JNIEnv *env, jclass class)
{
......@@ -227,7 +234,7 @@ JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_choice
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_butNot
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_Hammer_butnot
(JNIEnv *env, jclass class, jobject p, jobject q)
{
RETURNWRAP(env, h_butnot(UNWRAP(env, p), UNWRAP(env, q)));
......
jni/com_upstandinghackers_hammer_ParsedToken.c → src/bindings/java/native/src/main/native/com_upstandinghackers_hammer_ParsedToken.c
View file @ 26876183
#include "jhammer.h"
#include "com_upstandinghackers_hammer_ParsedToken.h"
#ifdef __GNUC__
#ifndef BRANCH_LIKELY
#define BRANCH_LIKELY(cond) __builtin_expect((cond),1)
#endif
#ifndef BRANCH_UNLIKELY
#define BRANCH_UNLIKELY(cond) __builtin_expect((cond),0)
#endif
#else /* unknown compiler */
#ifndef BRANCH_LIKELY
#define BRANCH_LIKELY(cond) (cond)
#endif
#ifndef BRANCH_UNLIKELY
#define BRANCH_UNLIKELY(cond) (cond)
#endif
#endif
#define HPT_UNWRAP(env, this) HParsedToken *inner = unwrap_parsed_token(env, this); assert(inner!=NULL)
HParsedToken *unwrap_parsed_token(JNIEnv *env, jobject obj)
......@@ -45,19 +61,56 @@ JNIEXPORT jbyteArray JNICALL Java_com_upstandinghackers_hammer_ParsedToken_getBy
(*env)->SetByteArrayRegion(env, outArray, (jsize) 0, (jsize)(inner->bytes.len), (jbyte *)(inner->bytes.token));
return outArray;
}
JNIEXPORT jlong JNICALL Java_com_upstandinghackers_hammer_ParsedToken_getSIntValue
#if 0
static jchar* format_number(uint64_t number, int length, int signedp, int *tlen, int had_neg) {
if (BRANCH_UNLIKELY(signedp && (number & 0x8000000000000000UL /* sign bit */) && length == 0)) {
jchar* ret = format_number((~number) + 1, 1, 0, tlen, 1);
ret[0] = '-';
return ret;
} else {
// no negative sign possible
if (BRANH_UNLIKELY(number == 0 && (length - had_neg) > 0)) {
*tlen = length;
return (jchar*)malloc(sizeof(jchar) * *tlen);
}
const jchar hexchars = {'0','1','2','3','4','5','6','7',
'8','9','A','B','C','D','E','F'};
jchar* ret - format_number(number >> 4, length + 1, 0, tlen, had_neg);
ret[*tlen - length - 1 + had_neg] = hexchars[number & 0xF];
return ret;
}
}
#endif
static jobject make_bignum(JNIEnv *env, uint64_t num, int signedp) {
jbyte bytebuf[9];
for (int i = 0; i < 8; i++) {
bytebuf[i+1] = (num >> (8 * (7 - i))) & 0xFF;
}
bytebuf[0] = (signedp && (num & (1LL << 63))) ? 0xFF : 0;
jbyteArray byteArray = (*env)->NewByteArray(env, 9);
(*env)->SetByteArrayRegion(env, byteArray, (jsize)0, (jsize)9, bytebuf);
jclass BigNum;
FIND_CLASS(BigNum, env, "java/math/BigInteger");
jmethodID bignum_ctor = (*env)->GetMethodID(env, BigNum, "<init>", "([B)V");
jobject ret = (*env)->NewObject(env, BigNum, bignum_ctor, byteArray);
return ret;
}
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_ParsedToken_getSIntValue
(JNIEnv *env, jobject this)
{
HPT_UNWRAP(env, this);
return (jlong) (inner->sint);
return make_bignum(env, inner->uint, 1);
}
JNIEXPORT jlong JNICALL Java_com_upstandinghackers_hammer_ParsedToken_getUIntValue
JNIEXPORT jobject JNICALL Java_com_upstandinghackers_hammer_ParsedToken_getUIntValue
(JNIEnv *env, jobject this)
{
HPT_UNWRAP(env, this);
return (jlong) (inner->uint);
return make_bignum(env, inner->uint, 0);
}
JNIEXPORT jdouble JNICALL Java_com_upstandinghackers_hammer_ParsedToken_getDoubleValue
......
jni/jhammer.h → src/bindings/java/native/src/main/native/jhammer.h
View file @ 26876183
#ifndef JHAMMER_H
#define JHAMMER_H
#include <jni.h>
#include "internal.h"
#include "../../../../../../internal.h"
#include <assert.h>
// Unsafe (non-asserting) helpers
......
src/bindings/java/native/src/test/java/HammerTest.java 0 → 100644
View file @ 26876183
package com.upstandinghackers.hammer;
import java.math.BigInteger;
import java.util.Arrays;
import org.testng.annotations.*;
import org.testng.Assert;
public class HammerTest extends TestSupport {
static {
System.loadLibrary("hammer-java");
}
@Test
public void TestToken() {
Parser parser;
parser = Hammer.token("95\u00a2");
checkParseOK(parser, "95\u00a2", "95\u00a2");
checkParseFail(parser, "95\u00a3");
}
@Test
public void TestCh() {
Parser parser;
parser = Hammer.ch(0xa2);
checkParseOK(parser, "\u00a2", new BigInteger("a2", 16));
checkParseFail(parser, "\u00a3");
}
@Test
public void TestChRange() {
Parser parser;
parser = Hammer.chRange(0x61, 0x63);
checkParseOK(parser, "b", new BigInteger("62", 16));
checkParseFail(parser, "d");
}
@Test
public void TestInt64() {
Parser parser;
parser = Hammer.int64();
checkParseOK(parser, "\u00ff\u00ff\u00ff\u00fe\u0000\u0000\u0000\u0000", new BigInteger("-200000000", 16));
checkParseFail(parser, "\u00ff\u00ff\u00ff\u00fe\u0000\u0000\u0000");
}
@Test
public void TestInt32() {
Parser parser;
parser = Hammer.int32();
checkParseOK(parser, "\u00ff\u00fe\u0000\u0000", new BigInteger("-20000", 16));
checkParseFail(parser, "\u00ff\u00fe\u0000");
checkParseOK(parser, "\u0000\u0002\u0000\u0000", new BigInteger("20000", 16));
checkParseFail(parser, "\u0000\u0002\u0000");
}
@Test
public void TestInt16() {
Parser parser;
parser = Hammer.int16();
checkParseOK(parser, "\u00fe\u0000", new BigInteger("-200", 16));
checkParseFail(parser, "\u00fe");
checkParseOK(parser, "\u0002\u0000", new BigInteger("200", 16));
checkParseFail(parser, "\u0002");
}
@Test
public void TestInt8() {
Parser parser;
parser = Hammer.int8();
checkParseOK(parser, "\u0088", new BigInteger("-78", 16));
checkParseFail(parser, "");
}
@Test
public void TestUint64() {
Parser parser;
parser = Hammer.uint64();
checkParseOK(parser, "\u0000\u0000\u0000\u0002\u0000\u0000\u0000\u0000", new BigInteger("200000000", 16));
checkParseFail(parser, "\u0000\u0000\u0000\u0002\u0000\u0000\u0000");
}
@Test
public void TestUint32() {
Parser parser;
parser = Hammer.uint32();
checkParseOK(parser, "\u0000\u0002\u0000\u0000", new BigInteger("20000", 16));
checkParseFail(parser, "\u0000\u0002\u0000");
}
@Test
public void TestUint16() {
Parser parser;
parser = Hammer.uint16();
checkParseOK(parser, "\u0002\u0000", new BigInteger("200", 16));
checkParseFail(parser, "\u0002");
}
@Test
public void TestUint8() {
Parser parser;
parser = Hammer.uint8();
checkParseOK(parser, "x", new BigInteger("78", 16));
checkParseFail(parser, "");
}
@Test
public void TestIntRange() {
Parser parser;
parser = Hammer.intRange(Hammer.uint8(), 0x3, 0xa);
checkParseOK(parser, "\u0005", new BigInteger("5", 16));
checkParseFail(parser, "\u000b");
}
@Test
public void TestWhitespace() {
Parser parser;
parser = Hammer.whitespace(Hammer.ch(0x61));
checkParseOK(parser, "a", new BigInteger("61", 16));
checkParseOK(parser, " a", new BigInteger("61", 16));
checkParseOK(parser, " a", new BigInteger("61", 16));
checkParseOK(parser, "\u0009a", new BigInteger("61", 16));
checkParseFail(parser, "_a");
parser = Hammer.whitespace(Hammer.endP());
checkParseOK(parser, "", null);
checkParseOK(parser, " ", null);
checkParseFail(parser, " x");
}
@Test
public void TestLeft() {
Parser parser;
parser = Hammer.left(Hammer.ch(0x61), Hammer.ch(0x20));
checkParseOK(parser, "a ", new BigInteger("61", 16));
checkParseFail(parser, "a");
checkParseFail(parser, " ");
checkParseFail(parser, "ba");
}
@Test
public void TestMiddle() {
Parser parser;
parser = Hammer.middle(Hammer.ch(" "), Hammer.ch("a"), Hammer.ch(" "));
checkParseOK(parser, " a ", new BigInteger("61", 16));
checkParseFail(parser, "a");
checkParseFail(parser, " a");
checkParseFail(parser, "a ");
checkParseFail(parser, " b ");
checkParseFail(parser, "ba ");
checkParseFail(parser, " ab");
}
@Test
public void TestIn() {
Parser parser;
parser = Hammer.in("abc");
checkParseOK(parser, "b", new BigInteger("62", 16));
checkParseFail(parser, "d");
}
@Test
public void TestNotIn() {
Parser parser;
parser = Hammer.notIn("abc");
checkParseOK(parser, "d", new BigInteger("64", 16));
checkParseFail(parser, "a");
}
@Test
public void TestEndP() {
Parser parser;
parser = Hammer.sequence(Hammer.ch("a"), Hammer.endP());
checkParseOK(parser, "a", new Object[]{ new BigInteger("61", 16)});
checkParseFail(parser, "aa");
}
@Test
public void TestNothingP() {
Parser parser;
parser = Hammer.nothingP();
checkParseFail(parser, "a");
}
@Test
public void TestSequence() {
Parser parser;
parser = Hammer.sequence(Hammer.ch("a"), Hammer.ch("b"));
checkParseOK(parser, "ab", new Object[]{ new BigInteger("61", 16), new BigInteger("62", 16)});
checkParseFail(parser, "a");
checkParseFail(parser, "b");
parser = Hammer.sequence(Hammer.ch("a"), Hammer.whitespace(Hammer.ch("b")));
checkParseOK(parser, "ab", new Object[]{ new BigInteger("61", 16), new BigInteger("62", 16)});
checkParseOK(parser, "a b", new Object[]{ new BigInteger("61", 16), new BigInteger("62", 16)});
checkParseOK(parser, "a b", new Object[]{ new BigInteger("61", 16), new BigInteger("62", 16)});
}
@Test
public void TestChoice() {
Parser parser;
parser = Hammer.choice(Hammer.ch("a"), Hammer.ch("b"));
checkParseOK(parser, "a", new BigInteger("61", 16));
checkParseOK(parser, "b", new BigInteger("62", 16));
checkParseOK(parser, "ab", new BigInteger("61", 16));
checkParseFail(parser, "c");
}
@Test
public void TestButnot() {
Parser parser;
parser = Hammer.butnot(Hammer.ch("a"), Hammer.token("ab"));
checkParseOK(parser, "a", new BigInteger("61", 16));
checkParseFail(parser, "ab");
checkParseOK(parser, "aa", new BigInteger("61", 16));
parser = Hammer.butnot(Hammer.chRange("0", "9"), Hammer.ch("6"));
checkParseOK(parser, "5", new BigInteger("35", 16));
checkParseFail(parser, "6");
}
@Test
public void TestDifference() {
Parser parser;
parser = Hammer.difference(Hammer.token("ab"), Hammer.ch("a"));
checkParseOK(parser, "ab", "ab");
checkParseFail(parser, "a");
}
@Test
public void TestXor() {
Parser parser;
parser = Hammer.xor(Hammer.chRange("0", "6"), Hammer.chRange("5", "9"));
checkParseOK(parser, "0", new BigInteger("30", 16));
checkParseOK(parser, "9", new BigInteger("39", 16));
checkParseFail(parser, "5");
checkParseFail(parser, "a");
}
@Test
public void TestMany() {
Parser parser;
parser = Hammer.many(Hammer.choice(Hammer.ch("a"), Hammer.ch("b")));
checkParseOK(parser, "", new Object[]{ });
checkParseOK(parser, "a", new Object[]{ new BigInteger("61", 16)});
checkParseOK(parser, "b", new Object[]{ new BigInteger("62", 16)});
checkParseOK(parser, "aabbaba", new Object[]{ new BigInteger("61", 16), new BigInteger("61", 16), new BigInteger("62", 16), new BigInteger("62", 16), new BigInteger("61", 16), new BigInteger("62", 16), new BigInteger("61", 16)});
}
@Test
public void TestMany1() {
Parser parser;
parser = Hammer.many1(Hammer.choice(Hammer.ch("a"), Hammer.ch("b")));
checkParseFail(parser, "");
checkParseOK(parser, "a", new Object[]{ new BigInteger("61", 16)});
checkParseOK(parser, "b", new Object[]{ new BigInteger("62", 16)});
checkParseOK(parser, "aabbaba", new Object[]{ new BigInteger("61", 16), new BigInteger("61", 16), new BigInteger("62", 16), new BigInteger("62", 16), new BigInteger("61", 16), new BigInteger("62", 16), new BigInteger("61", 16)});
checkParseFail(parser, "daabbabadef");
}
@Test
public void TestRepeatN() {
Parser parser;
parser = Hammer.repeatN(Hammer.choice(Hammer.ch("a"), Hammer.ch("b")), 0x2);
checkParseFail(parser, "adef");
checkParseOK(parser, "abdef", new Object[]{ new BigInteger("61", 16), new BigInteger("62", 16)});
checkParseFail(parser, "dabdef");
}
@Test
public void TestOptional() {
Parser parser;
parser = Hammer.sequence(Hammer.ch("a"), Hammer.optional(Hammer.choice(Hammer.ch("b"), Hammer.ch("c"))), Hammer.ch("d"));
checkParseOK(parser, "abd", new Object[]{ new BigInteger("61", 16), new BigInteger("62", 16), new BigInteger("64", 16)});
checkParseOK(parser, "acd", new Object[]{ new BigInteger("61", 16), new BigInteger("63", 16), new BigInteger("64", 16)});
checkParseOK(parser, "ad", new Object[]{ new BigInteger("61", 16), null, new BigInteger("64", 16)});
checkParseFail(parser, "aed");
checkParseFail(parser, "ab");
checkParseFail(parser, "ac");
}
@Test
public void TestIgnore() {
Parser parser;
parser = Hammer.sequence(Hammer.ch("a"), Hammer.ignore(Hammer.ch("b")), Hammer.ch("c"));
checkParseOK(parser, "abc", new Object[]{ new BigInteger("61", 16), new BigInteger("63", 16)});
checkParseFail(parser, "ac");
}
@Test
public void TestSepBy() {
Parser parser;
parser = Hammer.sepBy(Hammer.choice(Hammer.ch("1"), Hammer.ch("2"), Hammer.ch("3")), Hammer.ch(","));
checkParseOK(parser, "1,2,3", new Object[]{ new BigInteger("31", 16), new BigInteger("32", 16), new BigInteger("33", 16)});
checkParseOK(parser, "1,3,2", new Object[]{ new BigInteger("31", 16), new BigInteger("33", 16), new BigInteger("32", 16)});
checkParseOK(parser, "1,3", new Object[]{ new BigInteger("31", 16), new BigInteger("33", 16)});
checkParseOK(parser, "3", new Object[]{ new BigInteger("33", 16)});
checkParseOK(parser, "", new Object[]{ });
}
@Test
public void TestSepBy1() {
Parser parser;
parser = Hammer.sepBy1(Hammer.choice(Hammer.ch("1"), Hammer.ch("2"), Hammer.ch("3")), Hammer.ch(","));
checkParseOK(parser, "1,2,3", new Object[]{ new BigInteger("31", 16), new BigInteger("32", 16), new BigInteger("33", 16)});
checkParseOK(parser, "1,3,2", new Object[]{ new BigInteger("31", 16), new BigInteger("33", 16), new BigInteger("32", 16)});
checkParseOK(parser, "1,3", new Object[]{ new BigInteger("31", 16), new BigInteger("33", 16)});
checkParseOK(parser, "3", new Object[]{ new BigInteger("33", 16)});
checkParseFail(parser, "");
}
@Test
public void TestAnd() {
Parser parser;
parser = Hammer.sequence(Hammer.and(Hammer.ch("0")), Hammer.ch("0"));
checkParseOK(parser, "0", new Object[]{ new BigInteger("30", 16)});
checkParseFail(parser, "1");
parser = Hammer.sequence(Hammer.and(Hammer.ch("0")), Hammer.ch("1"));
checkParseFail(parser, "0");
checkParseFail(parser, "1");
parser = Hammer.sequence(Hammer.ch("1"), Hammer.and(Hammer.ch("2")));
checkParseOK(parser, "12", new Object[]{ new BigInteger("31", 16)});
checkParseFail(parser, "13");
}
@Test
public void TestNot() {
Parser parser;
parser = Hammer.sequence(Hammer.ch("a"), Hammer.choice(Hammer.token("+"), Hammer.token("++")), Hammer.ch("b"));
checkParseOK(parser, "a+b", new Object[]{ new BigInteger("61", 16), "+", new BigInteger("62", 16)});
checkParseFail(parser, "a++b");
parser = Hammer.sequence(Hammer.ch("a"), Hammer.choice(Hammer.sequence(Hammer.token("+"), Hammer.not(Hammer.ch("+"))), Hammer.token("++")), Hammer.ch("b"));
checkParseOK(parser, "a+b", new Object[]{ new BigInteger("61", 16), new Object[]{ "+"}, new BigInteger("62", 16)});
checkParseOK(parser, "a++b", new Object[]{ new BigInteger("61", 16), "++", new BigInteger("62", 16)});
}
@Test
public void TestRightrec() {
Parser parser;
Parser sp_rr = Hammer.indirect();
sp_rr.bindIndirect(Hammer.choice(Hammer.sequence(Hammer.ch("a"), sp_rr), Hammer.epsilonP()));
parser = sp_rr;
checkParseOK(parser, "a", new Object[]{ new BigInteger("61", 16)});
checkParseOK(parser, "aa", new Object[]{ new BigInteger("61", 16), new Object[]{ new BigInteger("61", 16)}});
checkParseOK(parser, "aaa", new Object[]{ new BigInteger("61", 16), new Object[]{ new BigInteger("61", 16), new Object[]{ new BigInteger("61", 16)}}});
}
}
src/bindings/java/native/src/test/java/TestSupport.java 0 → 100644
View file @ 26876183
package com.upstandinghackers.hammer;
import java.util.Arrays;
import java.math.BigInteger;
import org.testng.Assert;
public class TestSupport {
protected boolean deepEqual(ParsedToken p, Object known) {
if (p == null) {
return known == null;
}
switch (p.getTokenType()) {
case BYTES:
byte[] tmp_byte_buffer = p.getBytesValue();
String knowns = (String)known;
for (int i = 0; i < tmp_byte_buffer.length; i++) {
if (tmp_byte_buffer[i] != (byte)knowns.charAt(i)) {
return false;
}
}
return true;
case SINT:
return p.getSIntValue().equals(known);
case UINT:
return p.getUIntValue().equals(known);
case SEQUENCE:
int i=0;
for (ParsedToken tok : p.getSeqValue()) {
if (!deepEqual(tok, ((Object[])known)[i]))
return false;
++i;
}
return true;
case NONE:
return known == null;
default:
return false;
}
}
public void checkParseOK(Parser p, String input, Object expected) {
ParseResult res = p.parse(input);
if (res == null)
Assert.fail("parse failed");
if (!deepEqual(res.getAst(), expected))
Assert.fail("Parse does not match expected; got " + res.getAst().toString());
}
public void checkParseFail(Parser p, String input) {
ParseResult res = p.parse(input);
if (res != null)
Assert.fail("Parse unexpectedly succeeded; got " + res.getAst().toString());
}
}
src/bindings/java/pom.xml 0 → 100644
View file @ 26876183
<project>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.upstandinghackers</groupId>
<artifactId>hammer-parent</artifactId>
<version>0.9</version>
<relativePath>../../../pom.xml</relativePath>
</parent>
<groupId>com.upstandinghackers</groupId>
<artifactId>hammer</artifactId>
<version>0.9</version>
<name>Hammer JNI Bindings</name>
<packaging>pom</packaging>
<modules>
<module>java</module>
<module>native</module>
</modules>
<dependencies>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>6.1.1</version>
<scope>test</scope>
</dependency>
<!-- libhammer.so goes in here, uh, somehow -->
</dependencies>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>native-maven-plugin</artifactId>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>