diff --git a/generate-tarball.sh b/generate-tarball.sh new file mode 100755 index 0000000000000000000000000000000000000000..06dd20478726fa789642daadc829cfb5a4bd006c --- /dev/null +++ b/generate-tarball.sh @@ -0,0 +1,26 @@ +#!/bin/bash +set -e + +name=scala +version="$(sed -n 's/Version:\s*//p' *.spec)" + +# RETRIEVE +wget "https://github.com/scala/scala/archive/v${version}.tar.gz" -O "${name}-${version}.orig.tar.gz" + +rm -rf tarball-tmp +mkdir tarball-tmp +cd tarball-tmp +tar xf "../${name}-${version}.orig.tar.gz" + +# CLEAN TARBALL +find -name '*.jar' -delete +find -name '*.class' -delete +# Possibly proprietary code +find -name '*.dll' -delete +find -name '*.so' -delete +# Contains minified js of uncertain origin +rm -r */src/compiler/scala/tools/nsc/doc/html/resource/lib + +tar cf "../${name}-${version}.tar.gz" * +cd .. +rm -r tarball-tmp "${name}-${version}.orig.tar.gz" diff --git a/scala-2.10-jline.patch b/scala-2.10-jline.patch new file mode 100644 index 0000000000000000000000000000000000000000..59ec51836fb61761a59f3fc9a3eae0d59a64a989 --- /dev/null +++ b/scala-2.10-jline.patch @@ -0,0 +1,107 @@ +diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala +index 10f9724..2970276 100644 +--- a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala ++++ b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala +@@ -42,7 +42,7 @@ class JLineReader(_completion: => Completion) extends InteractiveReader { + def readOneKey(prompt: String) = { + this.print(prompt) + this.flush() +- this.readVirtualKey() ++ this.readCharacter() + } + def eraseLine() = consoleReader.resetPromptLine("", "", 0) + def redrawLineAndFlush(): Unit = { flush() ; drawLine() ; flush() } +diff --git a/src/compiler/scala/tools/nsc/interpreter/session/FileBackedHistory.scala b/src/compiler/scala/tools/nsc/interpreter/session/FileBackedHistory.scala +index dddfb1b..e598ac5 100644 +--- a/src/compiler/scala/tools/nsc/interpreter/session/FileBackedHistory.scala ++++ b/src/compiler/scala/tools/nsc/interpreter/session/FileBackedHistory.scala +@@ -13,7 +13,7 @@ import FileBackedHistory._ + /** TODO: file locking. + */ + trait FileBackedHistory extends JLineHistory with JPersistentHistory { +- def maxSize: Int ++ def maxSize: Int = 2500 + protected lazy val historyFile: File = defaultFile + private var isPersistent = true + +diff --git a/src/compiler/scala/tools/nsc/interpreter/session/JLineHistory.scala b/src/compiler/scala/tools/nsc/interpreter/session/JLineHistory.scala +index 18e0ee7..fc33192 100644 +--- a/src/compiler/scala/tools/nsc/interpreter/session/JLineHistory.scala ++++ b/src/compiler/scala/tools/nsc/interpreter/session/JLineHistory.scala +@@ -13,7 +13,6 @@ package session + trait JLineHistory extends JHistory with History { + def size: Int + def isEmpty: Boolean +- def index: Int + def clear(): Unit + def get(index: Int): CharSequence + def add(line: CharSequence): Unit +@@ -42,7 +41,8 @@ object JLineHistory { + addLineToFile(item) + } + } +- override def toString = "History(size = " + size + ", index = " + index + ")" ++ override def toString = "History(size = " + size + ", _index = " + index + ")" ++ override def maxSize: Int = 2500 + } + + def apply(): JLineHistory = try new JLineFileHistory catch { case x: Exception => new SimpleHistory() } +diff --git a/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala b/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala +index 9f4e2b9..8933849 100644 +--- a/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala ++++ b/src/compiler/scala/tools/nsc/interpreter/session/SimpleHistory.scala +@@ -10,7 +10,7 @@ package session + import scala.collection.mutable.{ Buffer, ListBuffer } + import scala.collection.JavaConverters._ + +-class SimpleHistory extends JLineHistory { ++class SimpleHistory extends JMemoryHistory with JLineHistory { + private var _index: Int = 0 + private val buf: Buffer[String] = new ListBuffer[String] + private def toEntries(): Seq[JEntry] = buf.zipWithIndex map { case (x, i) => Entry(i, x) } +@@ -32,27 +32,27 @@ class SimpleHistory extends JLineHistory { + def maxSize: Int = 2500 + def last = if (isEmpty) fail("last") else buf.last + +- def size = buf.size +- def index = _index +- def isEmpty = buf.isEmpty +- def clear() = buf.clear() +- def get(idx: Int): CharSequence = buf(idx) +- def add(item: CharSequence): Unit = buf += item +- def replace(item: CharSequence): Unit = { ++ override def size = buf.size ++ override def index = _index ++ override def isEmpty = buf.isEmpty ++ override def clear() = buf.clear() ++ override def get(idx: Int): CharSequence = buf(idx) ++ override def add(item: CharSequence): Unit = buf += item ++ override def replace(item: CharSequence): Unit = { + buf trimEnd 1 + add(item) + } +- def entries(idx: Int): JListIterator[JEntry] = toEntries().asJava.listIterator(idx) +- def entries(): JListIterator[JEntry] = toEntries().asJava.listIterator() +- def iterator: JIterator[JEntry] = toEntries().iterator.asJava +- +- def current() = if (index >= 0 && index < buf.size) buf(index) else fail("current()") +- def previous() = (index > 0) && minusOne +- def next() = (index <= lastIndex) && plusOne +- def moveToFirst() = (size > 0) && (index != 0) && setTo(0) +- def moveToLast() = (size > 0) && (index < lastIndex) && setTo(lastIndex) +- def moveTo(idx: Int) = (idx > 0) && (idx <= lastIndex) && setTo(idx) +- def moveToEnd(): Unit = setTo(size) ++ override def entries(idx: Int): JListIterator[JEntry] = toEntries().asJava.listIterator(idx) ++ override def entries(): JListIterator[JEntry] = toEntries().asJava.listIterator() ++ override def iterator: JIterator[JEntry] = toEntries().iterator.asJava ++ ++ override def current() = if (index >= 0 && index < buf.size) buf(index) else fail("current()") ++ override def previous() = (index > 0) && minusOne ++ override def next() = (index <= lastIndex) && plusOne ++ override def moveToFirst() = (size > 0) && (index != 0) && setTo(0) ++ override def moveToLast() = (size > 0) && (index < lastIndex) && setTo(lastIndex) ++ override def moveTo(idx: Int) = (idx > 0) && (idx <= lastIndex) && setTo(idx) ++ override def moveToEnd(): Unit = setTo(size) + + // scala legacy interface + def asList: List[JEntry] = toEntries().toList diff --git a/scala-2.10.0-tooltemplate.patch b/scala-2.10.0-tooltemplate.patch new file mode 100644 index 0000000000000000000000000000000000000000..81337a2b5882a22f7ef41628c1e1f9a8b98e3565 --- /dev/null +++ b/scala-2.10.0-tooltemplate.patch @@ -0,0 +1,21 @@ +diff -up scala-2.10.0-RC3/src/compiler/scala/tools/ant/templates/tool-unix.tmpl.tool scala-2.10.0-RC3/src/compiler/scala/tools/ant/templates/tool-unix.tmpl +--- scala-2.10.0-RC3/src/compiler/scala/tools/ant/templates/tool-unix.tmpl.tool 2012-11-21 17:01:54.000000000 +0100 ++++ scala-2.10.0-RC3/src/compiler/scala/tools/ant/templates/tool-unix.tmpl 2012-11-25 14:55:22.583111734 +0100 +@@ -68,7 +68,16 @@ if uname | grep -q ^MINGW; then + fi + + # Finding the root folder for this Scala distribution +-SCALA_HOME="$(findScalaHome)" ++export JAVA_HOMe=/usr/share/jvm/java ++ ++[ -r @@JAVADIR@@-utils/java-functions ] && . @@JAVADIR@@-utils/java-functions || exit 1 ++ ++set_javacmd || exit 3 ++check_java_env || exit 4 ++set_jvm_dirs || exit 5 ++ ++export SCALA_HOME=@@DATADIR@@/scala ++ + SEP=":" + + # Possible additional command line options diff --git a/scala-2.10.2-java7.patch b/scala-2.10.2-java7.patch new file mode 100644 index 0000000000000000000000000000000000000000..323ca42d0d5b8de4a29d2124f0865113891b5771 --- /dev/null +++ b/scala-2.10.2-java7.patch @@ -0,0 +1,198 @@ +diff -up scala-2.10.0-RC3-sources/src/swing/scala/swing/ComboBox.scala.jdk7 scala-2.10.0-RC3-sources/src/swing/scala/swing/ComboBox.scala +--- scala-2.10.0-RC3-sources/src/swing/scala/swing/ComboBox.scala.jdk7 2012-11-05 02:49:19.000000000 +0100 ++++ scala-2.10.0-RC3-sources/src/swing/scala/swing/ComboBox.scala 2012-12-07 23:29:32.821949227 +0100 +@@ -9,7 +9,7 @@ + package scala.swing + + import event._ +-import javax.swing.{JList, JComponent, JComboBox, JTextField, ComboBoxModel, AbstractListModel, ListCellRenderer} ++import javax.swing.{ JComponent, JComboBox, JTextField, ComboBoxModel, AbstractListModel, ListCellRenderer } + import java.awt.event.ActionListener + + object ComboBox { +@@ -118,10 +118,10 @@ object ComboBox { + implicit def floatEditor(c: ComboBox[Float]): Editor[Float] = new BuiltInEditor(c)(s => s.toFloat, s => s.toString) + implicit def doubleEditor(c: ComboBox[Double]): Editor[Double] = new BuiltInEditor(c)(s => s.toDouble, s => s.toString) + +- def newConstantModel[A](items: Seq[A]): ComboBoxModel = { +- new AbstractListModel with ComboBoxModel { ++ def newConstantModel[A](items: Seq[A]): ComboBoxModel[A] = { ++ new AbstractListModel[A] with ComboBoxModel[A] { + private var selected: A = if (items.isEmpty) null.asInstanceOf[A] else items(0) +- def getSelectedItem: AnyRef = selected.asInstanceOf[AnyRef] ++ def getSelectedItem = selected.asInstanceOf[AnyRef] + def setSelectedItem(a: Any) { + if ((selected != null && selected != a) || + selected == null && a != null) { +@@ -129,7 +129,7 @@ object ComboBox { + fireContentsChanged(this, -1, -1) + } + } +- def getElementAt(n: Int) = items(n).asInstanceOf[AnyRef] ++ def getElementAt(n: Int) = items(n).asInstanceOf[A] + def getSize = items.size + } + } +@@ -157,7 +157,7 @@ object ComboBox { + * @see javax.swing.JComboBox + */ + class ComboBox[A](items: Seq[A]) extends Component with Publisher { +- override lazy val peer: JComboBox = new JComboBox(ComboBox.newConstantModel(items)) with SuperMixin ++ override lazy val peer: JComboBox[A] = new JComboBox(ComboBox.newConstantModel(items)) with SuperMixin + + object selection extends Publisher { + def index: Int = peer.getSelectedIndex +@@ -182,7 +182,8 @@ class ComboBox[A](items: Seq[A]) extends + * of the component to its own defaults _after_ the renderer has been + * configured. That's Swing's principle of most suprise. + */ +- def renderer: ListView.Renderer[A] = ListView.Renderer.wrap(peer.getRenderer) ++ def renderer: ListView.Renderer[A] = ListView.Renderer.wrap[A](peer.getRenderer.asInstanceOf[ListCellRenderer[A]]) ++ // def renderer: ListView.Renderer[A] = ListView.Renderer.wrap(peer.getRenderer) + def renderer_=(r: ListView.Renderer[A]) { peer.setRenderer(r.peer) } + + /* XXX: currently not safe to expose: +@@ -201,8 +202,8 @@ class ComboBox[A](items: Seq[A]) extends + peer.setEditor(editor(this).comboBoxPeer) + } + +- def prototypeDisplayValue: Option[A] = toOption[A](peer.getPrototypeDisplayValue) ++ def prototypeDisplayValue: Option[A] = Option(peer.getPrototypeDisplayValue) + def prototypeDisplayValue_=(v: Option[A]) { +- peer.setPrototypeDisplayValue((v map toAnyRef).orNull) ++ peer.setPrototypeDisplayValue((v map toAnyRef).orNull.asInstanceOf[A]) + } + } +diff -up scala-2.10.0-RC3-sources/src/swing/scala/swing/ListView.scala.jdk7 scala-2.10.0-RC3-sources/src/swing/scala/swing/ListView.scala +--- scala-2.10.0-RC3-sources/src/swing/scala/swing/ListView.scala.jdk7 2012-11-05 02:49:19.000000000 +0100 ++++ scala-2.10.0-RC3-sources/src/swing/scala/swing/ListView.scala 2012-12-07 22:58:13.267919851 +0100 +@@ -24,21 +24,21 @@ object ListView { + val MultiInterval = Value(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION) + } + +- def wrap[A](c: JList) = new ListView[A] { ++ def wrap[A](c: JList[A]) = new ListView[A] { + override lazy val peer = c + } + + object Renderer { +- def wrap[A](r: ListCellRenderer): Renderer[A] = new Wrapped[A](r) ++ def wrap[A](r: ListCellRenderer[A]): Renderer[A] = new Wrapped[A](r) + + /** + * Wrapper for javax.swing.ListCellRenderers + */ +- class Wrapped[A](override val peer: ListCellRenderer) extends Renderer[A] { +- def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int) = { ++ class Wrapped[A](override val peer: ListCellRenderer[A]) extends Renderer[A] { ++ def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int) = { + Component.wrap(peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused).asInstanceOf[JComponent]) ++ } + } +- } + + /** + * Returns a renderer for items of type A. The given function +@@ -55,8 +55,8 @@ object ListView { + * + */ + def apply[A,B](f: A => B)(implicit renderer: Renderer[B]): Renderer[A] = new Renderer[A] { +- def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component = +- renderer.componentFor(list, isSelected, focused, f(a), index) ++ def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component = ++ renderer.componentFor(list.asInstanceOf[ListView[_ <: B]], isSelected, focused, f(a), index) + } + } + +@@ -69,11 +69,11 @@ object ListView { + * @see javax.swing.ListCellRenderer + */ + abstract class Renderer[-A] { +- def peer: ListCellRenderer = new ListCellRenderer { +- def getListCellRendererComponent(list: JList, a: Any, index: Int, isSelected: Boolean, focused: Boolean) = +- componentFor(ListView.wrap[A](list), isSelected, focused, a.asInstanceOf[A], index).peer ++ def peer: ListCellRenderer[_ >: A] = new ListCellRenderer[A] { ++ def getListCellRendererComponent(list: JList[_ <: A], a: A, index: Int, isSelected: Boolean, focused: Boolean) = ++ componentFor(ListView.wrap[A](list.asInstanceOf[JList[A]]), isSelected, focused, a, index).peer + } +- def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component ++ def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component + } + + /** +@@ -110,7 +110,7 @@ object ListView { + /** + * Configures the component before returning it. + */ +- def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component = { ++ def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component = { + preConfigure(list, isSelected, focused, a, index) + configure(list, isSelected, focused, a, index) + component +@@ -123,10 +123,10 @@ object ListView { + * that renders the string returned from an item's toString. + */ + implicit object GenericRenderer extends Renderer[Any] { +- override lazy val peer: ListCellRenderer = new DefaultListCellRenderer +- def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: Any, index: Int): Component = { +- val c = peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused).asInstanceOf[JComponent] +- Component.wrap(c) ++ override lazy val peer: ListCellRenderer[Any] = (new DefaultListCellRenderer).asInstanceOf[ListCellRenderer[Any]] ++ def componentFor(list: ListView[_ <: Any], isSelected: Boolean, focused: Boolean, a: Any, index: Int): Component = { ++ val c = peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused) ++ Component.wrap(c.asInstanceOf[JComponent]) + } + } + } +@@ -142,34 +142,34 @@ object ListView { + */ + class ListView[A] extends Component { + import ListView._ +- override lazy val peer: JList = new JList with SuperMixin ++ override lazy val peer: JList[A] = new JList[A] with SuperMixin + + def this(items: Seq[A]) = { + this() + listData = items + } + +- protected class ModelWrapper(val items: Seq[A]) extends AbstractListModel { +- def getElementAt(n: Int) = items(n).asInstanceOf[AnyRef] ++ protected class ModelWrapper[A](val items: Seq[A]) extends AbstractListModel[A] { ++ def getElementAt(n: Int) = items(n) + def getSize = items.size + } + + def listData: Seq[A] = peer.getModel match { +- case model: ModelWrapper => model.items +- case model @ _ => new Seq[A] { selfSeq => ++ case model: ModelWrapper[a] => model.items ++ case model => new Seq[A] { selfSeq => + def length = model.getSize + def iterator = new Iterator[A] { + var idx = 0 + def next = { idx += 1; apply(idx-1) } + def hasNext = idx < selfSeq.length + } +- def apply(n: Int) = model.getElementAt(n).asInstanceOf[A] ++ def apply(n: Int): A = model.getElementAt(n) + } + } + + def listData_=(items: Seq[A]) { +- peer.setModel(new AbstractListModel { +- def getElementAt(n: Int) = items(n).asInstanceOf[AnyRef] ++ peer.setModel(new AbstractListModel[A] { ++ def getElementAt(n: Int) = items(n) + def getSize = items.size + }) + } +@@ -216,7 +216,7 @@ class ListView[A] extends Component { + def adjusting = peer.getSelectionModel.getValueIsAdjusting + } + +- def renderer: ListView.Renderer[A] = ListView.Renderer.wrap(peer.getCellRenderer) ++ def renderer: ListView.Renderer[A] = ListView.Renderer.wrap[A](peer.getCellRenderer.asInstanceOf[ListCellRenderer[A]]) + def renderer_=(r: ListView.Renderer[A]) { peer.setCellRenderer(r.peer) } + + def fixedCellWidth = peer.getFixedCellWidth diff --git a/scala-2.10.3-bootstrap.tgz b/scala-2.10.3-bootstrap.tgz new file mode 100644 index 0000000000000000000000000000000000000000..803930ce55e16a84511f21d8e6479c81e026590b Binary files /dev/null and b/scala-2.10.3-bootstrap.tgz differ diff --git a/scala-2.10.3-compiler-pom.patch b/scala-2.10.3-compiler-pom.patch new file mode 100644 index 0000000000000000000000000000000000000000..fbc0ceee889764f689580e0366ffe068c7f80987 --- /dev/null +++ b/scala-2.10.3-compiler-pom.patch @@ -0,0 +1,15 @@ +diff -up scala-2.10.3/src/build/maven/scala-compiler-pom.xml.compiler-pom scala-2.10.3/src/build/maven/scala-compiler-pom.xml +--- scala-2.10.3/src/build/maven/scala-compiler-pom.xml.compiler-pom 2013-12-09 18:00:10.765090809 +0100 ++++ scala-2.10.3/src/build/maven/scala-compiler-pom.xml 2013-12-09 18:02:31.251138135 +0100 +@@ -43,9 +43,9 @@ + @VERSION@ + + +- org.scala-lang ++ jline + jline +- @VERSION@ ++ 2.10 + true + + diff --git a/scala-2.10.3-use_system_jline.patch b/scala-2.10.3-use_system_jline.patch new file mode 100644 index 0000000000000000000000000000000000000000..c8a43ebcd70bef8eef42799b99691756df329c4d --- /dev/null +++ b/scala-2.10.3-use_system_jline.patch @@ -0,0 +1,109 @@ +diff -up scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala.sysjline scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala +--- scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala.sysjline 2013-10-10 21:03:24.000000000 +0200 ++++ scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ConsoleReaderHelper.scala 2013-10-13 15:28:24.478283303 +0200 +@@ -6,8 +6,8 @@ + package scala.tools.nsc + package interpreter + +-import scala.tools.jline.console.{ ConsoleReader, CursorBuffer } +-import scala.tools.jline.console.completer.CompletionHandler ++import jline.console.{ ConsoleReader, CursorBuffer } ++import jline.console.completer.CompletionHandler + import Completion._ + + trait ConsoleReaderHelper extends ConsoleReader { +diff -up scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Delimited.scala.sysjline scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Delimited.scala +--- scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Delimited.scala.sysjline 2013-10-10 21:03:24.000000000 +0200 ++++ scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Delimited.scala 2013-10-13 15:28:24.483282990 +0200 +@@ -6,7 +6,7 @@ + package scala.tools.nsc + package interpreter + +-import scala.tools.jline.console.completer.ArgumentCompleter.{ ArgumentDelimiter, ArgumentList } ++import jline.console.completer.ArgumentCompleter.{ ArgumentDelimiter, ArgumentList } + + class JLineDelimiter extends ArgumentDelimiter { + def toJLine(args: List[String], cursor: Int) = args match { +diff -up scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala.sysjline scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala +--- scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala.sysjline 2013-10-10 21:03:24.000000000 +0200 ++++ scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala 2013-10-13 15:28:24.487282739 +0200 +@@ -6,8 +6,8 @@ + package scala.tools.nsc + package interpreter + +-import scala.tools.jline._ +-import scala.tools.jline.console.completer._ ++import jline._ ++import jline.console.completer._ + import Completion._ + import scala.collection.mutable.ListBuffer + +diff -up scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala.sysjline scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala +--- scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala.sysjline 2013-10-10 21:03:24.000000000 +0200 ++++ scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala 2013-10-13 15:30:16.619034744 +0200 +@@ -6,8 +6,8 @@ + package scala.tools.nsc + package interpreter + +-import scala.tools.jline.console.ConsoleReader +-import scala.tools.jline.console.completer._ ++import jline.console.ConsoleReader ++import jline.console.completer._ + import session._ + import scala.collection.JavaConverters._ + import Completion._ +@@ -71,6 +71,9 @@ class JLineReader(_completion: => Comple + def eraseLine() = consoleReader.eraseLine() + // Alternate implementation, not sure if/when I need this. + // def eraseLine() = while (consoleReader.delete()) { } +- def readOneLine(prompt: String) = consoleReader readLine prompt ++ def readOneLine(prompt: String) = { ++ consoleReader.setExpandEvents(false) ++ consoleReader readLine prompt ++ } + def readOneKey(prompt: String) = consoleReader readOneKey prompt + } +diff -up scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Parsed.scala.sysjline scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Parsed.scala +--- scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Parsed.scala.sysjline 2013-10-10 21:03:24.000000000 +0200 ++++ scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/Parsed.scala 2013-10-13 15:28:24.496282176 +0200 +@@ -6,7 +6,7 @@ + package scala.tools.nsc + package interpreter + +-import scala.tools.jline.console.completer.ArgumentCompleter.{ ArgumentDelimiter, ArgumentList } ++import jline.console.completer.ArgumentCompleter.{ ArgumentDelimiter, ArgumentList } + import util.returning + + /** One instance of a command buffer. +diff -up scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala.sysjline scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala +--- scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala.sysjline 2013-10-10 21:03:24.000000000 +0200 ++++ scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/ReplProps.scala 2013-10-13 15:28:24.500281925 +0200 +@@ -13,8 +13,8 @@ class ReplProps { + private def bool(name: String) = BooleanProp.keyExists(name) + private def int(name: String) = IntProp(name) + +- val jlineDebug = bool("scala.tools.jline.internal.Log.debug") +- val jlineTrace = bool("scala.tools.jline.internal.Log.trace") ++ val jlineDebug = bool("jline.internal.Log.debug") ++ val jlineTrace = bool("jline.internal.Log.trace") + + val info = bool("scala.repl.info") + val debug = bool("scala.repl.debug") +diff -up scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/session/package.scala.sysjline scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/session/package.scala +--- scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/session/package.scala.sysjline 2013-10-10 21:03:24.000000000 +0200 ++++ scala-2.10.3/src/compiler/scala/tools/nsc/interpreter/session/package.scala 2013-10-13 15:28:24.504281675 +0200 +@@ -14,10 +14,10 @@ package object session { + type JIterator[T] = java.util.Iterator[T] + type JListIterator[T] = java.util.ListIterator[T] + +- type JEntry = scala.tools.jline.console.history.History.Entry +- type JHistory = scala.tools.jline.console.history.History +- type JMemoryHistory = scala.tools.jline.console.history.MemoryHistory +- type JPersistentHistory = scala.tools.jline.console.history.PersistentHistory ++ type JEntry = jline.console.history.History.Entry ++ type JHistory = jline.console.history.History ++ type JMemoryHistory = jline.console.history.MemoryHistory ++ type JPersistentHistory = jline.console.history.PersistentHistory + + private[interpreter] implicit def charSequenceFix(x: CharSequence): String = x.toString + } diff --git a/scala-2.10.4-build_xml.patch b/scala-2.10.4-build_xml.patch new file mode 100644 index 0000000000000000000000000000000000000000..4d9a04b97f6fa95b45e6a8443cef2c608f4d532e --- /dev/null +++ b/scala-2.10.4-build_xml.patch @@ -0,0 +1,675 @@ +--- a/build.xml 2014-09-15 16:38:35.523938086 -0500 ++++ b/build.xml 2014-09-18 14:37:16.648133327 -0500 +@@ -1,6 +1,6 @@ + + +- ++ + + SuperSabbus for Scala core, builds the scala library and compiler. It can also package it as a simple distribution, tests it for stable bootstrapping and against the Scala test suite. + +@@ -44,8 +44,8 @@ + +- +- ++ ++ + + + +@@ -68,7 +68,7 @@ + + + +- ++ + + + +@@ -89,14 +89,13 @@ + + + ++ + + + + +- +- + + + +@@ -122,8 +121,8 @@ + + + +- +- ++ ++ + + + +@@ -181,91 +180,57 @@ + + + +- +- +- +- +- +- +- +- + + + + +- +- +- +- +- ++ + +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- ++ ++ ++ ++ ++ ++ ++ ++ ++ + +- +- +- +- +- +- +- ++ ++ ++ ++ ++ ++ ++ + +- +- ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + + + +@@ -337,7 +302,7 @@ + + + +- ++ + + + +@@ -466,6 +431,13 @@ + + There must be a variable of the shape @{stage}.compiler.path for all @{stage} in starr, locker, quick, strap. + --> ++ ++ ++ ++ ++ ++ ++ + + + +@@ -576,13 +548,6 @@ + + + +- +- +- +- +- +- +- + + + +@@ -605,12 +570,10 @@ + + + +- + + + + +- + + + +@@ -647,18 +610,6 @@ + + + +- +- +- +- +- +- +- +- +- +- +- +- + + + +@@ -733,10 +684,6 @@ + + + +- +- +- +- + + + +@@ -765,7 +712,8 @@ + + + +- ++ ++ + + + +- +- +- + + +- ++ + + + +- +- +- +- +- +- +- +- +- +- +- +- +- + +- ++ + + + +@@ -1331,7 +1258,7 @@ + +- ++ + + + +@@ -1378,7 +1305,6 @@ + + + +- + + + +@@ -1386,10 +1312,7 @@ + + + +- +- +- +- ++ + + + +@@ -1519,81 +1442,6 @@ + + + +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- + +@@ -1604,71 +1452,37 @@ + + + +- +- +- +- +- +- +- +- + + + + +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- ++ + + + +- +- +- +- +- ++ + + + + +- +- +- + + + +- ++ + + ++ ++ ++ pack.bin.tool.path is ${packBinToolPath} ++ ++ ++ ++ ++ ++ ++ + + + +@@ -1688,6 +1502,7 @@ + + + ++ + + + +@@ -1740,15 +1555,14 @@ + + + +- +- +- +- ++ ++ ++ ++ ++ + +- +- ++ + +- + + + +@@ -1758,12 +1572,6 @@ + + + +- +- +- +- +- +- + + + +@@ -1771,10 +1579,12 @@ + + + ++ + + + + ++ + + + +- ++ + + + +- ++ + + + +@@ -1836,7 +1646,6 @@ + + + +- + + + +@@ -2027,10 +1836,9 @@ + + + +- ++ + + +- + + + +@@ -2047,7 +1855,6 @@ + + + +- + + + diff --git a/scala-2.10.4.tgz b/scala-2.10.4.tgz new file mode 100644 index 0000000000000000000000000000000000000000..960bce0adaa718e90283279740141cf442e64e5d Binary files /dev/null and b/scala-2.10.4.tgz differ diff --git a/scala-2.10.6-scaladoc-resources.patch b/scala-2.10.6-scaladoc-resources.patch new file mode 100644 index 0000000000000000000000000000000000000000..86a7da67e567af4fafea8ba808fd7b724a505fef --- /dev/null +++ b/scala-2.10.6-scaladoc-resources.patch @@ -0,0 +1,25 @@ +From f9b8176c668d3dff01da73fe65308bc50e355226 Mon Sep 17 00:00:00 2001 +From: Mikolaj Izdebski +Date: Fri, 12 Oct 2018 16:43:59 +0000 +Subject: [PATCH] Stop scaladoc from bundling web assets in generated docs + +--- + src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala | 2 -- + 1 file changed, 2 deletions(-) + +diff --git a/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala b/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala +index 4630c3d..648a588 100644 +--- a/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala ++++ b/src/compiler/scala/tools/nsc/doc/html/HtmlFactory.scala +@@ -121,8 +121,6 @@ class HtmlFactory(val universe: doc.Universe, index: doc.Index) { + + DiagramGenerator.initialize(universe.settings) + +- libResources foreach (s => copyResource("lib/" + s)) +- + new page.Index(universe, index) writeFor this + new page.IndexScript(universe, index) writeFor this + +-- +2.17.2 + diff --git a/scala-2.10.6.tar.gz b/scala-2.10.6.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..44beed25e4fc0aa29371c0bef613b71a60e2fb5f Binary files /dev/null and b/scala-2.10.6.tar.gz differ diff --git a/scala-bootstript.xml b/scala-bootstript.xml new file mode 100644 index 0000000000000000000000000000000000000000..282d4122c797d732b3dc5518ff582ea9a2996d66 --- /dev/null +++ b/scala-bootstript.xml @@ -0,0 +1,152 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/scala-library-2.10.0-bnd.properties b/scala-library-2.10.0-bnd.properties new file mode 100644 index 0000000000000000000000000000000000000000..eacc122b9ec3166ad92a946de68c89eaba4bf5c3 --- /dev/null +++ b/scala-library-2.10.0-bnd.properties @@ -0,0 +1,3 @@ +Bundle-Name: Scala Distribution +Bundle-SymbolicName: org.scala-ide.scala.library +Export-Package: scala.* diff --git a/scala-mime-info.xml b/scala-mime-info.xml new file mode 100644 index 0000000000000000000000000000000000000000..914f6ccd70f48dee1ef06febc719961ae5c3155e --- /dev/null +++ b/scala-mime-info.xml @@ -0,0 +1,8 @@ + + + + + Scala source code + + + diff --git a/scala.ant.d b/scala.ant.d new file mode 100644 index 0000000000000000000000000000000000000000..9be890a74cf1b117553c52d3d7dc20951ea4dbcf --- /dev/null +++ b/scala.ant.d @@ -0,0 +1 @@ +scala diff --git a/scala.gitinfo b/scala.gitinfo new file mode 100644 index 0000000000000000000000000000000000000000..fd0ff1a6bc9d40ef886d388b99fe46fb44ea7ec8 --- /dev/null +++ b/scala.gitinfo @@ -0,0 +1,2 @@ +b66a39653b9bccab72036ba58fec5fd7d596d313 +20140209 diff --git a/scala.keys b/scala.keys new file mode 100644 index 0000000000000000000000000000000000000000..a5fe0ea160c9c5d29ab89826049e2f1a6da8a572 --- /dev/null +++ b/scala.keys @@ -0,0 +1,4 @@ +text/x-scala + description=Scala source code + category=Software Development/Source Code + can_be_executable=TRUE diff --git a/scala.mime b/scala.mime new file mode 100644 index 0000000000000000000000000000000000000000..5d7d426bfd4edd8606ced9de3716610b76409997 --- /dev/null +++ b/scala.mime @@ -0,0 +1,2 @@ +text/x-scala + ext: scala diff --git a/scala.spec b/scala.spec new file mode 100644 index 0000000000000000000000000000000000000000..09d87664a44c10460568ffb78d8b65855bbd63c0 --- /dev/null +++ b/scala.spec @@ -0,0 +1,160 @@ +%global _default_patch_fuzz 2 +%{?filter_setup: %filter_from_requires /ant/d; %filter_setup} + +Name: scala +Version: 2.10.6 +Release: 12 +Summary: Combination of object-oriented and functional programming +License: BSD and CC0 and Public Domain +URL: http://www.scala-lang.org/ +Source0: %{name}-%{version}.tar.gz +Source1: scala-library-2.10.0-bnd.properties +Source2: scala-2.10.3-bootstrap.tgz +Source3: scala.gitinfo +Source4: http://www.scala-lang.org/files/archive/scala-2.10.4.tgz +Source5: generate-tarball.sh +Source6: scala.keys +Source7: scala.mime +Source8: scala-mime-info.xml +Source9: scala.ant.d +Source10: scala-bootstript.xml +Patch0: scala-2.10.0-tooltemplate.patch +Patch1: scala-2.10.3-use_system_jline.patch +Patch2: scala-2.10.3-compiler-pom.patch +Patch3: scala-2.10.2-java7.patch +Patch4: scala-2.10-jline.patch +Patch5: scala-2.10.4-build_xml.patch +BuildArch: noarch + +BuildRequires: java-devel >= 1:1.7.0, ant, ant-junit, ant-contrib, jline >= 2.10, aqute-bnd, junit, javapackages-local, scala +Requires: jpackage-utils, jansi, java-headless >= 1:1.7.0, jline >= 2.10 +Provides: %{name}-apidoc%{?_isa} %{name}-apidoc +Obsoletes: %{name}-apidoc +Provides: %{name}-swing%{?_isa} %{name}-swing +Obsoletes: %{name}-swing +Provides: ant-scala%{?_isa} ant-scala +Obsoletes: ant-scala + +%description +Scala combines object-oriented and functional programming in one concise, high-level language. +Scala's static types help avoid bugs in complex applications, and its JVM and JavaScript runtimes +let you build high-performance systems with easy access to huge ecosystems of libraries. +It provides a common, uniform, and all-encompassing framework for collection types. +This framework enables you to work with data in memory at a high level, with the basic building +blocks of a program being whole collections, instead of individual elements. +This style of programming requires some learning. Fortunately, the adaptation is helped by several +nice properties of the Scala collections. They are easy to use, concise, safe, fast, universal. + +%prep +%autosetup -p1 + +echo "starr.version=2.10.4\nstarr.use.released=0" > starr.number + +cd src +rm -rf jline +cd - + +sed -i '/is not supported by/d' build.xml +sed -i '/exec.*pull-binary-libs.sh/d' build.xml + +pushd lib + rm -rf scala-compiler.jar scala-library.jar scala-reflect.jar + ln -s $(build-classpath scala/scala-compiler.jar) scala-compiler.jar + ln -s $(build-classpath scala/scala-library.jar) scala-library.jar + ln -s $(build-classpath scala/scala-reflect.jar) scala-reflect.jar + pushd ant + rm -rf ant.jar ant-contrib.jar + ln -s $(build-classpath ant.jar) ant.jar + ln -s $(build-classpath ant/ant-contrib) ant-contrib.jar + popd +popd + +cp -rf %{SOURCE10} . + +sed -i -e 's!@JLINE@!%{_javadir}/jline/jline.jar!g' build.xml + +echo echo $(head -n 1 %{SOURCE3}) > tools/get-scala-commit-sha +echo echo $(tail -n 1 %{SOURCE3}) > tools/get-scala-commit-date + +chmod 755 tools/get-scala-* + +%build +export ANT_OPTS="-Xms2048m -Xmx2048m %{nil}" + +ant build || exit 1 +cd build/pack/lib +mv scala-library.jar scala-library.jar.no +bnd wrap --properties %{SOURCE1} --output scala-library.jar --version "%{version}" scala-library.jar.no +cd - + +%check +pushd test/files/run + rm -rf parserJavaIdent.scala t6223.scala + pushd ../presentation + rm -rf implicit-member t5708 ide-bug-1000349 ide-bug-1000475 ide-bug-1000531 visibility ping-pong callcc-interpreter + pushd ../../osgi/src + rm -rf ReflectionToolboxTest.scala + popd + popd +popd + +%install +install -d $RPM_BUILD_ROOT%{_bindir} +for prog in scaladoc fsc scala scalac scalap; do + install -p -m 755 build/pack/bin/$prog $RPM_BUILD_ROOT%{_bindir} +done + +install -p -m 755 -d $RPM_BUILD_ROOT%{_datadir}/scala/lib + +%mvn_file ':{*}:jar:' %{name}/@1 %{_datadir}/scala/lib/@1 +%mvn_file ':{*}:pom:' %{name}/@1 JPP.%{name}-@1 + +%mvn_package :scala-swing swing + +for libname in scala-compiler scala-library scala-reflect scalap scala-swing ; do + sed -i "s|@VERSION@|%{version}|" src/build/maven/$libname-pom.xml + sed -i "s|@RELEASE_REPOSITORY@|http://nexus.scala-tools.org/content/repositories/releases|" src/build/maven/$libname-pom.xml + sed -i "s|@SNAPSHOT_REPOSITORY@|http://nexus.scala-tools.org/content/repositories/snapshots|" src/build/maven/$libname-pom.xml + %mvn_artifact src/build/maven/$libname-pom.xml build/pack/lib/$libname.jar +done +ln -s $(abs2rel %{_javadir}/jline/jline.jar %{_datadir}/scala/lib) $RPM_BUILD_ROOT%{_datadir}/scala/lib +ln -s $(abs2rel %{_javadir}/jansi/jansi.jar %{_datadir}/scala/lib) $RPM_BUILD_ROOT%{_datadir}/scala/lib + +%mvn_install +install -d $RPM_BUILD_ROOT%{_sysconfdir}/ant.d +install -p -m 644 %{SOURCE9} $RPM_BUILD_ROOT%{_sysconfdir}/ant.d/scala + +install -d $RPM_BUILD_ROOT%{_datadir}/mime-info +install -p -m 644 %{SOURCE6} %{SOURCE7} $RPM_BUILD_ROOT%{_datadir}/mime-info/ + +install -d $RPM_BUILD_ROOT%{_datadir}/mime/packages/ +install -p -m 644 %{SOURCE8} $RPM_BUILD_ROOT%{_datadir}/mime/packages/ + +sed -i -e 's,@JAVADIR@,%{_javadir},g' -e 's,@DATADIR@,%{_datadir},g' $RPM_BUILD_ROOT%{_bindir}/* + +%post +touch --no-create %{_datadir}/mime/packages > /dev/null 2>&1 || : + +%postun +if [ $1 -eq 0 ]; then +update-mime-database %{_datadir}/mime > /dev/null 2>&1 || : +fi + +%posttrans +update-mime-database %{?fedora:-n} %{_datadir}/mime > /dev/null 2>&1 || : + +%files -f .mfiles +%license docs/LICENSE +%config %{_sysconfdir}/ant.d/* +%{_bindir}/* +%dir %{_datadir}/%{name} +%dir %{_datadir}/%{name}/lib +%{_datadir}/%{name}/lib/*.jar +%{_datadir}/mime-info/* +%{_datadir}/mime/packages/* +%{_javadir}/%{name}/* +/usr/share/maven* + +%changelog +* Fri Dec 13 2019 openEuler Buildteam - 2.10.6-12 +- Package init