Tiny parser + scanner being used + complete Tiny drivers + complete diff check between static and dynamic

.github/workflows/test.yml

@@ -15,6 +15,8 @@ jobs:
     env:
       SCALA_VERSION: "2.13.12"
       SCALA_MAJOR: "2.13"
+      JFLEX_URL: "https://github.com/boyland/JFlex/releases/download/v1.5+scala.1/JFlex.jar"
+      SCALA_BISON_URL: "https://github.com/boyland/scala-bison/releases/download/v1.2/scala-bison-2.13.jar"
 
     steps:
     - name: Checkout code
@@ -53,6 +55,13 @@ jobs:
         cd utilities/tests
         make all
 
+    - name: Download JFlex and scala-bison
+      run: |
+        mkdir -p "$HOME/git/scala-bison"
+        mkdir -p "$HOME/Documents/Courses/sp26-cs654/etc"
+        wget -q -O "$HOME/git/scala-bison/scala-bison-2.13.jar" "$SCALA_BISON_URL"
+        wget -q -O "$HOME/Documents/Courses/sp26-cs654/etc/JFlex.jar" "$JFLEX_URL"
+
     - name: Run examples Scala tests
       run: |
         cd examples/scala/tests
@@ -63,6 +72,12 @@ jobs:
         cd examples
         ../bin/aps2scala -DCOTo -G -p .:../base test-canonicals
 
+    - name: Run compare-evaluators
+      if: github.event_name == 'push'
+      run: |
+        cd examples/scala
+        ./compare-evaluators.sh
+
     - name: Clean up
       if: always()
       run: make clean

examples/scala/Makefile

@@ -22,11 +22,14 @@ IMPL_SUFFIX = .scala
 endif
 
 SCALAGEN = simple.scala classic-binding.scala tiny.scala broad-fiber-cycle.scala \
+	below-fiber-cycle.scala below-single-fiber-cycle.scala local-fiber-cycle.scala \
 	test-coll.scala test-use-coll.scala test-cycle.scala use-global.scala \
 	grammar.scala first.scala follow.scala nullable.scala	\
 	farrow-lv-tree.scala farrow-lv.static.scala \
 	farrow-ubd-tree.scala farrow-ubd.static.scala farrow-ubd-fiber.static.scala \
-	broad-fiber-cycle.static.scala classic-binding.static.scala \
+	broad-fiber-cycle.static.scala below-fiber-cycle.static.scala \
+	below-single-fiber-cycle.static.scala local-fiber-cycle.static.scala \
+	classic-binding.static.scala \
 	grammar.scala first.static.scala follow.static.scala nullable.static.scala \
 	nested-cycles.static.scala \
 	test-coll.static.scala test-use-coll.static.scala test-cycle.static.scala use-global.static.scala
@@ -57,6 +60,9 @@ all : NestedUbd_implicit.class NestedUbdDriver.class
 all : NestedUbdFiber_implicit.class NestedUbdFiberDriver.class
 all : nested_cycles_implicit.class NestedCyclesDriver.class
 all : broad_fiber_cycle_implicit.class BroadFiberCycleDriver.class
+all : below_fiber_cycle_implicit.class BelowFiberCycleDriver.class
+all : below_single_fiber_cycle_implicit.class BelowSingleFiberCycleDriver.class
+all : local_fiber_cycle_implicit.class LocalFiberCycleDriver.class
 
 .PHONY: run
 
@@ -267,21 +273,21 @@ test_coll_implicit.class : test-coll${IMPL_SUFFIX} tiny_implicit.class
 	${SCALAC} ${SCALACFLAGS} $<
 	@touch $@
 
-test_use_coll_implicit.class : test-use-coll${IMPL_SUFFIX}
+test_use_coll_implicit.class : test-use-coll${IMPL_SUFFIX} tiny_implicit.class
 	${SCALAC} ${SCALACFLAGS} $<
 	@touch $@
 
-TestCollDriver.class : test_coll_implicit.class test-coll-driver.scala
+TestCollDriver.class : test_coll_implicit.class TinyParser.class test-coll-driver.scala
 	${SCALAC} ${SCALACFLAGS}  test-coll-driver.scala
 
-TestUseCollDriver.class : test_use_coll_implicit.class test-use-coll-driver.scala tiny_implicit.class
+TestUseCollDriver.class : test_use_coll_implicit.class TinyParser.class test-use-coll-driver.scala tiny_implicit.class
 	${SCALAC} ${SCALACFLAGS}  test-use-coll-driver.scala
 
-test_cycle_implicit.class : test-cycle${IMPL_SUFFIX}
+test_cycle_implicit.class : test-cycle${IMPL_SUFFIX} tiny_implicit.class
 	${SCALAC} ${SCALACFLAGS} $<
 	@touch $@
 
-TestCycleDriver.class : test_cycle_implicit.class test-cycle-driver.scala
+TestCycleDriver.class : test_cycle_implicit.class TinyParser.class test-cycle-driver.scala
 	${SCALAC} ${SCALACFLAGS}  test-cycle-driver.scala
 
 grammar_implicit.class : grammar.scala first${IMPL_SUFFIX} follow${IMPL_SUFFIX} nullable${IMPL_SUFFIX}
@@ -307,10 +313,37 @@ broad_fiber_cycle_implicit.class : broad-fiber-cycle${IMPL_SUFFIX}
 	${SCALAC} ${SCALACFLAGS} $<
 	@touch $@
 
-BroadFiberCycleDriver.class : broad_fiber_cycle_implicit.class tiny_implicit.class
+BroadFiberCycleDriver.class : broad_fiber_cycle_implicit.class tiny_implicit.class TinyParser.class
 BroadFiberCycleDriver.class : broad-fiber-cycle-driver.scala
 	${SCALAC} ${SCALACFLAGS} $<
 
+below_fiber_cycle_implicit.class : tiny_implicit.class
+below_fiber_cycle_implicit.class : below-fiber-cycle${IMPL_SUFFIX}
+	${SCALAC} ${SCALACFLAGS} $<
+	@touch $@
+
+BelowFiberCycleDriver.class : below_fiber_cycle_implicit.class tiny_implicit.class TinyParser.class
+BelowFiberCycleDriver.class : below-fiber-cycle-driver.scala
+	${SCALAC} ${SCALACFLAGS} $<
+
+below_single_fiber_cycle_implicit.class : tiny_implicit.class
+below_single_fiber_cycle_implicit.class : below-single-fiber-cycle${IMPL_SUFFIX}
+	${SCALAC} ${SCALACFLAGS} $<
+	@touch $@
+
+BelowSingleFiberCycleDriver.class : below_single_fiber_cycle_implicit.class tiny_implicit.class TinyParser.class
+BelowSingleFiberCycleDriver.class : below-single-fiber-cycle-driver.scala
+	${SCALAC} ${SCALACFLAGS} $<
+
+local_fiber_cycle_implicit.class : tiny_implicit.class
+local_fiber_cycle_implicit.class : local-fiber-cycle${IMPL_SUFFIX}
+	${SCALAC} ${SCALACFLAGS} $<
+	@touch $@
+
+LocalFiberCycleDriver.class : local_fiber_cycle_implicit.class tiny_implicit.class TinyParser.class
+LocalFiberCycleDriver.class : local-fiber-cycle-driver.scala
+	${SCALAC} ${SCALACFLAGS} $<
+
 .PHONY: %.run
 
 %.run : %.class

examples/scala/README

@@ -3,10 +3,15 @@ make EVALUATOR=STATIC ARGS="farrow-lv.program" FarrowLvDriver.run
 make EVALUATOR=STATIC ARGS="farrow-ubd.program" FarrowUbdDriver.run
 make EVALUATOR=STATIC ARGS="farrow-ubd.program" FarrowUbdFiberDriver.run
 make EVALUATOR=STATIC ARGS="grammar.cfg" GrammarDriver.run
-make EVALUATOR=STATIC BroadFiberCycleDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" BroadFiberCycleDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" BelowFiberCycleDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" BelowSingleFiberCycleDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" LocalFiberCycleDriver.run
 make EVALUATOR=STATIC Classic.run
-make EVALUATOR=STATIC TestCollDriver.run
-make EVALUATOR=STATIC TestUseCollDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" TestCollDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" TestUseCollDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" TestCycleDriver.run
+make EVALUATOR=STATIC ARGS="tiny.program" UseGlobal.run
 make EVALUATOR=STATIC NestedCyclesDriver.run
 make EVALUATOR=STATIC ARGS="nested-ubd.program" NestedUbdDriver.run
 make EVALUATOR=STATIC ARGS="nested-ubd.program" NestedUbdFiberDriver.run

examples/scala/below-fiber-cycle-driver.scala

@@ -0,0 +1,24 @@
+object BelowFiberCycleDriver extends App
+{
+    val m = new M_TINY("Tiny");
+    val t_Tiny = m.t_Result;
+    val p = new TinyParser(m);
+
+    val w = if (args.length > 0) {
+      p.parseFile(args(0))
+    } else {
+      t_Tiny.f_root(t_Tiny.f_branch(t_Tiny.f_leaf(3),t_Tiny.f_leaf(4)))
+    };
+
+    if (args.contains("--debug")) Debug.activate();
+
+    m.finish();
+
+    val m2 = new M_BELOW_FIBER_CYCLE("Test below",m);
+    val w2 = w.asInstanceOf[m2.T_Root];
+
+    m2.finish();
+
+    println("Results:");
+    println("answer is " + m2.v_answer(w2));
+}

examples/scala/below-single-fiber-cycle-driver.scala

@@ -0,0 +1,24 @@
+object BelowSingleFiberCycleDriver extends App
+{
+    val m = new M_TINY("Tiny");
+    val t_Tiny = m.t_Result;
+    val p = new TinyParser(m);
+
+    val w = if (args.length > 0) {
+      p.parseFile(args(0))
+    } else {
+      t_Tiny.f_root(t_Tiny.f_branch(t_Tiny.f_leaf(3),t_Tiny.f_leaf(4)))
+    };
+
+    if (args.contains("--debug")) Debug.activate();
+
+    m.finish();
+
+    val m2 = new M_BELOW_SINGLE_FIBER_CYCLE("Test below single",m);
+    val w2 = w.asInstanceOf[m2.T_Root];
+
+    m2.finish();
+
+    println("Results:");
+    println("answer is " + m2.v_answer(w2));
+}

examples/scala/broad-fiber-cycle-driver.scala

@@ -1,12 +1,16 @@
 object BroadFiberCycleDriver extends App
 {
     val m = new M_TINY("Tiny");
-    type T_Tiny = m.T_Result;
     val t_Tiny = m.t_Result;
+    val p = new TinyParser(m);
 
-    val w = t_Tiny.v_root(t_Tiny.v_branch(t_Tiny.v_leaf(3),t_Tiny.v_leaf(4)));
+    val w = if (args.length > 0) {
+      p.parseFile(args(0))
+    } else {
+      t_Tiny.f_root(t_Tiny.f_branch(t_Tiny.f_leaf(3),t_Tiny.f_leaf(4)))
+    };
 
-    Debug.activate();
+    if (args.contains("--debug")) Debug.activate();
 
     m.finish();
 
@@ -15,5 +19,6 @@ object BroadFiberCycleDriver extends App
 
     m2.finish();
 
-    println("answer is " + m2.v_answer);
+    println("Results:");
+    println("answer is " + m2.v_answer(w2));
 }

examples/scala/compare-evaluators.sh

@@ -0,0 +1,124 @@
+#!/bin/bash
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+EVALUATORS=(DYNAMIC STATIC)
+
+extract_results() {
+  sed -n '/^Results:$/,$p'
+}
+
+run_with_evaluator() {
+  local evaluator="$1"
+  local driver="$2"
+  local args="$3"
+  local outfile="$4"
+
+  rm -f *_implicit.class "${driver}.class"
+  if ! make EVALUATOR="$evaluator" "$driver.class" > /dev/null 2>&1; then
+    return 1
+  fi
+  make EVALUATOR="$evaluator" ARGS="$args" "$driver.run" 2>&1 | extract_results > "$outfile"
+}
+
+run_driver() {
+  local driver="$1"
+  shift
+  local args="$*"
+  local pass=true
+  local build_failed=false
+  local tmpdir
+  tmpdir=$(mktemp -d)
+
+  echo "--- $driver ${args:+(${args})} ---"
+
+  local built_evaluators=()
+  for eval in "${EVALUATORS[@]}"; do
+    echo "  running $eval ..."
+    if ! run_with_evaluator "$eval" "$driver" "$args" "$tmpdir/$eval"; then
+      echo "  FAIL: $eval build failed"
+      build_failed=true
+      continue
+    fi
+    if [ ! -s "$tmpdir/$eval" ]; then
+      echo "  WARNING: $eval produced no Results: output"
+      pass=false
+      continue
+    fi
+    built_evaluators+=("$eval")
+  done
+
+  if $build_failed; then
+    rm -rf "$tmpdir"
+    return 1
+  fi
+
+  local n=${#built_evaluators[@]}
+  if [ $n -lt 2 ]; then
+    echo "  FAIL: fewer than 2 evaluators built successfully"
+    rm -rf "$tmpdir"
+    return 1
+  fi
+
+  for ((i=0; i<n-1; i++)); do
+    for ((j=i+1; j<n; j++)); do
+      local e1="${built_evaluators[$i]}"
+      local e2="${built_evaluators[$j]}"
+      if diff -q "$tmpdir/$e1" "$tmpdir/$e2" > /dev/null 2>&1; then
+        echo "  PASS ($e1 == $e2)"
+      else
+        echo "  FAIL ($e1 != $e2)"
+        diff "$tmpdir/$e1" "$tmpdir/$e2" | sed 's/^/    /'
+        pass=false
+      fi
+    done
+  done
+
+  rm -rf "$tmpdir"
+  $pass
+}
+
+if [ $# -gt 0 ]; then
+  driver="$1"
+  shift
+  run_driver "$driver" "$@"
+  exit $?
+fi
+
+TESTS=(
+  "BroadFiberCycleDriver|tiny.program"
+  "BelowFiberCycleDriver|tiny.program"
+  "BelowSingleFiberCycleDriver|tiny.program"
+  "LocalFiberCycleDriver|tiny.program"
+  "TestCollDriver|tiny.program"
+  "TestUseCollDriver|tiny.program"
+  "TestCycleDriver|tiny.program"
+  "UseGlobal|tiny.program"
+  "FarrowUbdDriver|farrow-ubd.program"
+  "FarrowUbdFiberDriver|farrow-ubd.program"
+  "NestedUbdDriver|nested-ubd.program"
+  "NestedUbdFiberDriver|nested-ubd.program"
+)
+
+failures=0
+total=0
+
+for test in "${TESTS[@]}"; do
+  IFS="|" read -r driver args <<< "$test"
+  total=$((total + 1))
+  return_code=0
+  run_driver "$driver" "$args" || return_code=$?
+  if [ $return_code -eq 1 ]; then
+    failures=$((failures + 1))
+  fi
+  echo ""
+done
+
+echo "=============================="
+echo "$((total - failures))/$total passed"
+if [ $failures -gt 0 ]; then
+  echo "$failures FAILED"
+  exit 1
+fi
+echo "All passed!"

examples/scala/local-fiber-cycle-driver.scala

@@ -0,0 +1,24 @@
+object LocalFiberCycleDriver extends App
+{
+    val m = new M_TINY("Tiny");
+    val t_Tiny = m.t_Result;
+    val p = new TinyParser(m);
+
+    val w = if (args.length > 0) {
+      p.parseFile(args(0))
+    } else {
+      t_Tiny.f_root(t_Tiny.f_branch(t_Tiny.f_leaf(3),t_Tiny.f_leaf(4)))
+    };
+
+    if (args.contains("--debug")) Debug.activate();
+
+    m.finish();
+
+    val m2 = new M_LOCAL_FIBER_CYCLE("Test local",m);
+    val w2 = w.asInstanceOf[m2.T_Root];
+
+    m2.finish();
+
+    println("Results:");
+    println("answer is " + m2.v_answer(w2));
+}