diff options
34 files changed, 859 insertions, 971 deletions
diff --git a/config/list/library.lst b/config/list/library.lst index b34361b6f2..4f7f5a4aae 100644 --- a/config/list/library.lst +++ b/config/list/library.lst @@ -225,18 +225,24 @@ xml/EntityRef.scala xml/ExternalID.scala xml/FactoryAdapter.scala xml/LoggedNodeFactory.scala +xml/MetaData.scala +xml/NamespaceBinding.scala xml/Node.scala xml/NodeBuffer.scala xml/NodeFactory.scala xml/NodeSeq.scala -xml/NodeTraverser.scala +#xml/NodeTraverser.scala +xml/Null.scala xml/Parsing.scala +xml/PrefixedAttribute.scala xml/PrettyPrinter.scala xml/ProcInstr.scala xml/SpecialNode.scala xml/Text.scala xml/TextBuffer.scala +xml/TopScope.scala xml/UName.scala +xml/UnprefixedAttribute.scala xml/Utility.scala xml/dtd/ContentModel.scala @@ -250,13 +256,11 @@ xml/dtd/ValidationException.scala xml/nobinding/NoBindingFactoryAdapter.scala xml/nobinding/XML.scala -xml/parsing/AttribValue.scala xml/parsing/ConstructingHandler.scala xml/parsing/ConstructingParser.scala xml/parsing/FatalError.scala xml/parsing/MarkupHandler.scala xml/parsing/MarkupParser.scala -xml/parsing/XSDHandler.scala xml/path/Expression.scala xml/transform/BasicTransformer.scala diff --git a/sources/scala/Predef.scala b/sources/scala/Predef.scala index c29d751a7d..d9ce59f82b 100644 --- a/sources/scala/Predef.scala +++ b/sources/scala/Predef.scala @@ -43,6 +43,7 @@ object Predef { def scd[a](x: Any, y: a): a = y; val namespace$default = ""; + val $scope = null; type Function[-a,+b] = Function1[a,b]; diff --git a/sources/scala/tools/scalac/ast/TreeList.scala b/sources/scala/tools/scalac/ast/TreeList.scala index 5dc3dda7a5..198e4fdbbd 100644 --- a/sources/scala/tools/scalac/ast/TreeList.scala +++ b/sources/scala/tools/scalac/ast/TreeList.scala @@ -14,7 +14,7 @@ package scala.tools.scalac.ast { /** List of trees. */ -final class TreeList(ts: Array[Tree]) { +final class TreeList(ts: Array[Tree]) with Iterable[Tree] { private var trees = ts; private var len = ts.length; @@ -47,6 +47,14 @@ final class TreeList(ts: Array[Tree]) { len = 0; } + def elements = new Iterator[Tree] { // don't change treelist while iterating! + private var i = 0; + def hasNext: Boolean = i < len; + def next: Tree = + if (i < len) { val x = trees(i) ; i = i + 1 ; x } + else error("next on empty iterator"); + } + def length(): int = len; def get(i: int): Tree = trees(i); diff --git a/sources/scala/tools/scalac/ast/parser/MarkupParser.scala b/sources/scala/tools/scalac/ast/parser/MarkupParser.scala index f46d0d7a3c..75d30bdfcd 100644 --- a/sources/scala/tools/scalac/ast/parser/MarkupParser.scala +++ b/sources/scala/tools/scalac/ast/parser/MarkupParser.scala @@ -292,6 +292,7 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean /*[Duplicate]*/ def element: Tree = { val pos1 = pos; val Tuple2(qname, attrMap) = xTag; + //Console.println("MarkupParser::element("+qname+","+attrMap+")"); if(ch == '/') { // empty element xToken('/'); xToken('>'); diff --git a/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala b/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala index 27d70707f6..41b1d69871 100644 --- a/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala +++ b/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala @@ -17,13 +17,12 @@ import scala.tools.scalac.util.NewArray; import scala.collection.immutable.{ Map, ListMap }; import scala.collection.mutable; import scala.xml.{Text,TextBuffer}; -import scala.xml.parsing.{ AttribValue, MarkupHandler }; import scalac.util.{ Name, Names, TypeNames } ; package scala.tools.scalac.ast.parser { /** this class builds instance of Tree that represent XML */ -class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: Boolean ) /*extends MarkupHandler[Tree,Tree]*/ { +class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: Boolean ) { import scala.tools.scalac.ast.{TreeList => myTreeList} @@ -31,8 +30,15 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: val _ArrayBuffer = Name.fromString("ArrayBuffer"); val _Attribute = Name.fromString("Attribute"); + val _MetaData = Name.fromString("MetaData"); + val _NamespaceBinding = Name.fromString("NamespaceBinding"); val _NodeBuffer = Name.fromString("NodeBuffer"); val _NoAttributes = Name.fromString("NoAttributes"); + + val _Null = Name.fromString("Null"); + + val _PrefixedAttribute = Name.fromString("PrefixedAttribute"); + val _UnprefixedAttribute = Name.fromString("UnprefixedAttribute"); val _TreeMap = Name.fromString("TreeMap"); val _Elem = Name.fromString("Elem"); val _Seq = Name.fromString("Seq"); @@ -74,6 +80,21 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: private def _scala_xml( pos: int, name: Name ) = make.Select( pos, _scala( pos, _xml ), name ); + private def _scala_xml_MetaData( pos: int ) = + p.convertToTypeId(_scala_xml( pos, _MetaData )); + + private def _scala_xml_NamespaceBinding( pos: int ) = + p.convertToTypeId(_scala_xml( pos, _NamespaceBinding )); + + private def _scala_xml_Null( pos: int ) = + _scala_xml( pos, _Null ); + + private def _scala_xml_PrefixedAttribute( pos: int ) = + p.convertToConstr( _scala_xml( pos, _PrefixedAttribute )); + + private def _scala_xml_UnprefixedAttribute( pos: int ) = + p.convertToConstr( _scala_xml( pos, _UnprefixedAttribute )); + private def _scala_xml_Node( pos: int ) = _scala_xml( pos, _Node ); @@ -170,12 +191,13 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: * @todo map: a map of attributes !!! */ - protected def mkXML(pos: int, isPattern: boolean, namespace: Tree, label: Tree, attrs: Array[Tree], children: mutable.Buffer[Tree]): Tree = { + protected def mkXML(pos: int, isPattern: boolean, pre: Tree, label: Tree, attrs: /*Array[*/Tree/*]*/ , scope:Tree, children: mutable.Buffer[Tree]): Tree = { if( isPattern ) { val ts = new mutable.ArrayBuffer[Tree](); - ts.append( namespace ); + ts.append( pre ); ts.append( label ); ts.append( new Tree$Ident( Names.PATTERN_WILDCARD ) ); // attributes? + ts.append( new Tree$Ident( Names.PATTERN_WILDCARD ) ); // scope? convertToTextPat( children ); ts ++ children; make.Apply(pos, @@ -183,8 +205,12 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: bufferToArray( ts )) } else { val ab = new scala.collection.mutable.ArrayBuffer[Tree](); - ab + namespace; + ab + pre; ab + label; + ab + attrs; + ab + scope; + + /* if(( attrs.length ) == 0 ) ab + _scala_xml_Node_NoAttributes( pos ) else @@ -193,6 +219,7 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: _scala_xml_Node_NoAttributes( pos ), Names.PERCENT ), attrs); + */ if(( children.length ) > 0 ) ab + make.Typed(pos, makeXMLseq( pos, children ), @@ -243,7 +270,11 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: make.New( pos, constr ); } - // create + // code to create attribute + /* + scala.xml.Attribute(uri, "key", [value]) + */ + def makeAttribute( pos: int, ns:String, key:String, value:Tree ):Tree = make.Apply(pos, _scala_xml_Attribute(pos), @@ -311,7 +342,8 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: true, new Tree$Ident( Names.PATTERN_WILDCARD ):Tree, gen.mkStringLit( pos, n ):Tree, - Predef.Array[Tree](), + null, //Predef.Array[Tree](), + null, args); protected def convertToTextPat(t: Tree): Tree = t match { @@ -369,11 +401,13 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: + /** returns Some(prefix) if pre:name, None otherwise */ def getPrefix( name:String ):Option[String] = { val i = name.indexOf(':'); if( i != -1 ) Some( name.substring(0, i) ) else None } + /** splits */ protected def qualifiedAttr( pos:Int, namespace:String, name:String ):Pair[String,String] = { getPrefix( name ).match { case Some( pref ) => @@ -394,54 +428,229 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: Pair( "namespace$default", name ); } + final val _md = Name.fromString("$md"); + final val _scope = Name.fromString("$scope"); + final val _tmpscope = Name.fromString("$tmpscope"); + /** makes an element */ - def element(pos: int, label: String, attrMap: mutable.Map[String,Tree], args: mutable.Buffer[Tree]): Tree = { + def element(pos: int, qname: String, attrMap: mutable.Map[String,Tree], args: mutable.Buffer[Tree]): Tree = { + //Console.println("SymbolicXMLBuilder::element("+pos+","+qname+","+attrMap+","+args+")"); var setNS = new mutable.HashMap[String, Tree]; + + val tlist = new myTreeList(); + val tlist2 = new myTreeList(); + + def handleNamespaceBinding(pre:String, uri:Tree): Unit = { + val t = make.Assign(pos, + make.Ident(pos, _tmpscope), + make.New(pos, + make.Apply( + pos, + p.convertToConstr(_scala_xml( pos, _NamespaceBinding )), + Predef.Array[Tree]( + {if(pre==null) + gen.mkNullLit(pos) + else + gen.mkStringLit(pos, pre)} , + uri, + make.Ident(pos, _tmpscope))) + ) + ); + tlist.append( t ); + //Console.println("SymbolicXMLBuilder::handleNamespaceBinding:"); + //Console.println(t.toString()); + + } + /* DEBUG */ val attrIt = attrMap.keys; while( attrIt.hasNext ) { val z = attrIt.next; - if( z.startsWith("xmlns") ) { + if( z.startsWith("xmlns") ) { // handle namespace val i = z.indexOf(':'); if( i == -1 ) - setNS.update("default", attrMap( z ) ); + handleNamespaceBinding(null, attrMap( z )); + //setNS.update("default", attrMap( z ) ); else { val zz = z.substring( i+1, z.length() ); - setNS.update( zz, attrMap( z ) ); + //setNS.update( zz, attrMap( z ) ); + handleNamespaceBinding(zz, attrMap( z )); } attrMap -= z; } } + + val moreNamespaces = (0 < tlist.length()); + /* */ - val i = label.indexOf(':'); - val Pair( namespace, newlabel ) = qualified( pos, label ); - - var attr:Array[Tree] = - if( attrMap.isEmpty ) - Tree.EMPTY_ARRAY - else { - val attrs:Array[Tree] = new Array[Tree](attrMap.size); - /* DEBUG */ - var k = 0; - var it = attrMap.elements; - while( it.hasNext ) { - val ansk = it.next; - val Pair( ns, aname ) = qualifiedAttr( pos, namespace, ansk._1 ); - attrs( k ) = makeAttribute( pos, ns, aname, ansk._2 ); - k = k + 1; - } - /* */ - attrs + val i = qname.indexOf(':'); + + var newlabel = qname; + val pre = getPrefix(qname).match { + case Some(p) => + newlabel = qname.substring(p.length()+1, qname.length()); + p; + case None => + null + } + //val Pair( pre, newlabel ) = qualified( pos, label ); + //Console.println("SymbolicXMLBuilder::(489) "+pre); + + // make attributes + + def handlePrefixedAttribute(pre:String, key:String, value:Tree): Unit = { + val t = + make.Assign(pos, + make.Ident(pos, _md), + make.New(pos, + make.Apply(pos, + _scala_xml_PrefixedAttribute(pos), + Predef.Array[Tree]( + gen.mkStringLit(pos,pre), + gen.mkStringLit(pos,key), + value, + make.Ident(pos, _md) + ) + ) + ) + ); + tlist2.append( t ); + // Console.println("SymbolicXMLBuilder::handlePrefixed :"); + // Console.println(t.toString()); + } + def handleUnprefixedAttribute(key:String, value:Tree): Unit = { + val t = make.Assign(pos, + make.Ident(pos, _md), + make.New(pos, + make.Apply(pos, + _scala_xml_UnprefixedAttribute(pos), + Predef.Array[Tree]( + gen.mkStringLit(pos,key), + value, + make.Ident(pos, _md) + ) + ) + ) + ); + tlist2.append(t); + //Console.println("SymbolicXMLBuilder::handlePrefixed :"); + //Console.println(t.toString()); + + } + + //var attr:Array[Tree] = + // if( attrMap.isEmpty ) + // Tree.EMPTY_ARRAY ; //gen.mkNullLit(pos); // + // else { + // val attrs:Array[Tree] = new Array[Tree](attrMap.size); + /* DEBUG */ + // var k = 0; + var it = attrMap.elements; + while( it.hasNext ) { + val ansk = it.next; + + getPrefix( ansk._1 ).match { + case Some(pre) => + val key = ansk._1.substring(pre.length()+1, ansk._1.length()); + handlePrefixedAttribute(pre, key, ansk._2); + case None => + handleUnprefixedAttribute(ansk._1, ansk._2); } + //val Pair( ns, aname ) = qualifiedAttr( pos, namespace, ansk._1 ); + //attrs( k ) = makeAttribute( pos, ns, aname, ansk._2 ); + //k = k + 1; + } + /* */ + // attrs + + // } + + val moreAttributes = (0 < tlist2.length()); + + val ts = new mutable.ArrayBuffer[Tree](); + + if(moreNamespaces) { + ts + make.ValDef(pos, + Modifiers.MUTABLE, + _tmpscope, + _scala_xml_NamespaceBinding(pos), + make.Ident(pos, _scope)); + ts ++ tlist; + } + + //Console.println("printing ts"); + //for(val t <- ts) + // Console.println(t.toString()); + + val ts2 = new mutable.ArrayBuffer[Tree](); + + if(moreNamespaces) { + ts2 + make.ValDef(pos, 0, _scope, Tree.Empty, make.Ident(pos, _tmpscope)); + } + if(moreAttributes) { + ts2 + make.ValDef(pos, + Modifiers.MUTABLE, + _md, + _scala_xml_MetaData(pos), + _scala_xml_Null(pos)); + ts2 ++ tlist2; + } + //Console.println("printing ts2"); + //for(val t <- ts2) + // Console.println(t.toString()); + + val stms:Array[Tree] = new Array[Tree]( ts.length ); + ts.elements.copyToArray( stms, 0 ); + + val stms2:Array[Tree] = new Array[Tree]( ts2.length ); + ts2.elements.copyToArray( stms2, 0 ); + + val makeSymbolicPrefix = { + if(null == pre) + gen.mkNullLit(pos) + else + gen.mkStringLit(pos,pre) + } + + val makeSymbolicAttrs = { + if(moreAttributes) + make.Ident(pos, _md) //attr:Array[Tree], + else + _scala_xml_Null(pos) + } var t = mkXML(pos, false, - make.Ident(pos, Name.fromString(namespace)):Tree, + makeSymbolicPrefix, gen.mkStringLit(pos, newlabel):Tree, - attr:Array[Tree], + makeSymbolicAttrs, + make.Ident(pos, _scope), args); - /* DEBUG */ + /* + Console.println("printing _pre"); + Console.println({if(null == pre) "null" else pre.toString()}); + Console.println("printing newlabel"); + Console.println(newlabel.toString()); + Console.println("printing _scope"); + Console.println(_scope.toString()); + Console.println("printing t"); + Console.println(t.toString()); + */ + + if(0 < stms2.length) { + t = make.Block( pos, stms2, t ); + } + ; + if(0 < stms.length) { + t = make.Block(pos, stms, t); + } + ; + //Console.println("SymbolicXMLBuilder::element returns :"); + //Console.println(res.toString()); + + t + /* DEBUG if( !setNS.isEmpty ) { val nsStms = new Array[Tree]( setNS.size ); var i = 0; @@ -450,10 +659,10 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS: i = i + 1; } make.Block( pos, nsStms, t ) - } else { - /* */ + } else { t - } + } */ + } def setNamespacePrefix(pos:Int, pref:String, uri:Tree) = diff --git a/sources/scala/tools/scalac/transformer/TransMatch.scala b/sources/scala/tools/scalac/transformer/TransMatch.scala index 592bfb236e..f654b609b8 100644 --- a/sources/scala/tools/scalac/transformer/TransMatch.scala +++ b/sources/scala/tools/scalac/transformer/TransMatch.scala @@ -134,7 +134,10 @@ class TransMatch( global:scalac_Global ) } i = i+1; } + //Console.println("TransMatch: "); + //for(val ci <- cases) Console.println(ci); if( containsReg ) { + //Console.println("TransMatch: isRegular!"); /* val pe = new matching.PatternExp(global.definitions); // TEST var j = 0; @@ -149,13 +152,17 @@ class TransMatch( global:scalac_Global ) am.construct( matcher, cases.asInstanceOf[ Array[Tree] ] ); matcher.tree } else { + //Console.println("TransMatch: NOT regular"); val pm = new matching.PatternMatcher( cunit ); pm.initialize(root, currentOwner, restpe, true ); try{ pm.construct( cases.asInstanceOf[ Array[Tree] ] ); } catch { case e:Throwable => - Console.println("failed on pats"+scala.Iterator.fromArray(cases).toList.mkString("","\n","")+", message\n"+e.getMessage()) + Console.print("failed on pats "+scala.Iterator.fromArray(cases).toList.mkString("","\n","")+", message\n"+e.getMessage()); + Console.println(" with exception:"+e.getMessage()); + //e.printStackTrace(); + Debug.abort() } if (global.log()) { global.log("internal pattern matching structure"); diff --git a/sources/scala/tools/scalac/transformer/matching/AlgebraicMatcher.scala b/sources/scala/tools/scalac/transformer/matching/AlgebraicMatcher.scala index 9d566fcb1d..fc1c960019 100644 --- a/sources/scala/tools/scalac/transformer/matching/AlgebraicMatcher.scala +++ b/sources/scala/tools/scalac/transformer/matching/AlgebraicMatcher.scala @@ -75,7 +75,7 @@ import java.util.Iterator ; /** initializes this AlgebraicMatcher, see Matcher.initialize void initialize() {} */ - + /* def isStarApply(tree: Tree.Apply): Boolean = { val params:Array[Symbol] = tree.fun.getType().valueParams(); //System.err.println( tree.fun.type.resultType().symbol() ); @@ -84,7 +84,7 @@ import java.util.Iterator ; && params.length > 0 && (params(params.length-1).flags & Modifiers.REPEATED) != 0; } - +*/ //////////// generator methods override def toTree(): Tree = { @@ -145,6 +145,7 @@ import java.util.Iterator ; def callSequenceMatcher(node: PatternNode, selector: Tree): Tree = { + //Console.println("calling sequent matcher for"+node); /* ???????????????????????? necessary to test whether is a Seq? gen.If(selector.pos, maybe cf.And( cf.Is(selector, seqpat.type()) )???) */ diff --git a/sources/scala/tools/scalac/transformer/matching/WordAutomInScala.scala b/sources/scala/tools/scalac/transformer/matching/WordAutomInScala.scala index fa1cee2467..3bc4323182 100644 --- a/sources/scala/tools/scalac/transformer/matching/WordAutomInScala.scala +++ b/sources/scala/tools/scalac/transformer/matching/WordAutomInScala.scala @@ -55,7 +55,7 @@ package scala.tools.scalac.transformer.matching { result = cf.gen.mkBlock( cf.pos, NewArray.Tree ( - gen.ValDef( iterSym, cf.newIterator( selector )), + gen.ValDef( iterSym, cf.newIterator( selector.duplicate() )), gen.ValDef( stateSym, gen.mkIntLit( cf.pos, 0) ), gen.ValDef( resultSym, theDefDef )), result ); diff --git a/sources/scala/tools/scalac/typechecker/Analyzer.scala b/sources/scala/tools/scalac/typechecker/Analyzer.scala index cb351151b4..facaafc7ee 100644 --- a/sources/scala/tools/scalac/typechecker/Analyzer.scala +++ b/sources/scala/tools/scalac/typechecker/Analyzer.scala @@ -2615,6 +2615,36 @@ class Analyzer(global: scalac_Global, descr: AnalyzerPhase) extends Transformer( errorTermTree(tree) } } + case Tree.Apply(fn, args) if ((mode & PATTERNmode) != 0) => + val fn1 = transform(fn, mode | FUNmode, pt); + val argMode = PATTERNmode; + // type arguments with formals as prototypes if they exist. + fn1.setType(infer.freshInstance(fn1.getType())); + val argtypes = transformArgs( + tree.pos, fn1.symbol(), Symbol.EMPTY_ARRAY, fn1.getType(), argMode, args, pt); + + + if (argtypes == null) + setError(tree) + else { + var i: int = 0; + while (i < argtypes.length && !argtypes(i).isError()) + i = i + 1; + if (i < argtypes.length) setError(tree); + + fn1.getType() match { + case Type$MethodType(params, restp) => + copy.Apply(tree, fn1, args).setType(restp); + case _ => + if (!fn1.getType().isError()) + error( + tree.pos, + infer.applyErrorMsg( + "", fn1, " cannot be applied to ", argtypes, pt)); + errorTermTree(tree) + } + } + case Tree.Apply(fn, args) => mode = mode & ~SEQUENCEmode; diff --git a/sources/scala/xml/BindingFactoryAdapter.scala b/sources/scala/xml/BindingFactoryAdapter.scala index 9f63fb7cf6..2278e3e45e 100644 --- a/sources/scala/xml/BindingFactoryAdapter.scala +++ b/sources/scala/xml/BindingFactoryAdapter.scala @@ -24,7 +24,7 @@ abstract class BindingFactoryAdapter extends FactoryAdapter() with NodeFactory[N /** mapping from element names to an element constructor * (constr:Seq[Node],HashMap[String,String] => Node) */ - val f: Map[ String, (AttributeSeq,Seq[Node]) => Node ]; + val f: Map[ String, (MetaData, NamespaceBinding, Seq[Node]) => Node ]; /** mapping from element names to a truth value indicating * whether the corresponding element may have text children @@ -59,32 +59,29 @@ abstract class BindingFactoryAdapter extends FactoryAdapter() with NodeFactory[N } } - protected def create(uname: UName, attrs: AttributeSeq, children:Seq[Node]): Node = { + protected def create(uname: UName, attrs: MetaData, scope: NamespaceBinding, children:Seq[Node]): Node = { if( this.namespace == uname.uri ) { val c = getConstructor( uname.label ); - c( attrs, children ); + c( attrs, scope, children ); } else { - Elem( uname.uri, uname.label, attrs, children:_* ); + Elem( uname.uri, uname.label, attrs, scope, children:_* ); } } /** creates an element. see also compress */ - def createNode(uri:String, - elemName:String, - attribs:HashMap[Pair[String,String],String], - children:List[Node] ):Node = { - val uri$ = uri.intern(); - val attribs1 = AttributeSeq.fromMap(attribs); + def createNode(pre:String, elemName: String, attribs: MetaData, scope: NamespaceBinding, children:List[Node] ):Node = { + //val uri$ = uri.intern(); + //val attribs1 = AttributeSeq.fromMap(attribs); // 2do:optimize if( !compress ) { // get constructor val c = getConstructor(elemName); - c( attribs1, children ); + c( attribs, scope, children ); } else { // do hash-consing - val ahc = attribs.toList.hashCode(); - makeNode(UName(uri$, elemName), attribs1, children); + val ahc = attribs.hashCode(); + makeNode(pre, elemName, attribs, scope, children); /* val h = Utility.hashCode( uri$, elemName, ahc, children ); cache.get( h ).match { @@ -106,6 +103,6 @@ abstract class BindingFactoryAdapter extends FactoryAdapter() with NodeFactory[N } // createNode /** creates PCDATA element */ - def createText( text:String ):Text = new Text( text ); + def createText( text:String ) = new Text( text ); } // BindingFactoryAdapter diff --git a/sources/scala/xml/Elem.scala b/sources/scala/xml/Elem.scala index e6482e3cce..8f9208a6ee 100644 --- a/sources/scala/xml/Elem.scala +++ b/sources/scala/xml/Elem.scala @@ -14,48 +14,37 @@ import scala.collection.mutable.ArrayBuffer; /** The case class <code>Elem</code> implements the Node trait, * providing an immutable data object representing an XML element. * - * @param namespace the namespace code as assigned by NamespaceRegistry + * @param prefix (may be null) * @param label the element name * @param attribute the attribute map * @param child the children of this node * @author Burak Emir */ -case class Elem( namespace$$:String, label$$: String, attributes: AttributeSeq, child: Node*) extends Node { +// "val" is redundant for non-overriding arguments +case class Elem(override val prefix:String, val label: String, override val attributes: MetaData, override val scope: NamespaceBinding, val child: Node*) extends Node { - final val namespaceIntern = namespace$$.intern(); - final def namespace = namespaceIntern; + //@todo: copy the children, + // setting namespace scope if necessary + // cleaning adjacent text nodes if necessary - final val labelIntern = label$$.intern(); - final def label = labelIntern; + //final val namespaceIntern = namespace$$.intern(); + //final def namespace = namespaceIntern; - final override def typeTag$:Int = 0; - - def this(namespace: String, label: String, child: Node*) = - this(namespace, label, Node.NoAttributes, child:_*); + //final val labelIntern = label$$.intern(); + //final def label = labelIntern; - def this(label: String, child: Node*) = - this(Node.EmptyNamespace, label, Node.NoAttributes, child:_*); + final override def typeTag$:Int = 0; /** Return a new element with updated attributes * * @param attrs * @return a new symbol with updated attributes */ - final def %(attrs: Seq[Attribute]): Elem = - Elem(namespace, - label, - AttributeSeq.fromAttrs((attributes.toList ::: attrs.toList):_*), - child:_*) ; - - /** Return a new symbol with updated attribute - * - * @param attr - * @return a new symbol with updated attribute - */ - final def %(attr: Attribute): Elem = - Elem(namespace, + final def %(attrs: MetaData): Elem = + Elem(prefix, label, - AttributeSeq.fromAttrs((attributes.toList ::: attr :: Nil):_*), + attrs.append(attributes), + scope, child:_*) ; } diff --git a/sources/scala/xml/FactoryAdapter.scala b/sources/scala/xml/FactoryAdapter.scala index f9cf1fb4aa..9b08612cfc 100644 --- a/sources/scala/xml/FactoryAdapter.scala +++ b/sources/scala/xml/FactoryAdapter.scala @@ -30,16 +30,17 @@ import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParser; -//import org.xml.sax.helpers.XMLReaderFactory; - -/** SAX adapter class, for use with Java SAX parser -**/ +/** SAX adapter class, for use with Java SAX parser. Keeps track of + * namespace bindings, without relying on namespace handling of the + * underlying SAX parser. + */ abstract class FactoryAdapter extends DefaultHandler() { - val buffer = new StringBuffer(); - val attribStack = new Stack[HashMap[Pair[String,String],String]]; - val hStack = new Stack[Node]; // [ element ] contains siblings - val tagStack = new Stack[String]; // [String] + val buffer = new StringBuffer(); + val attribStack = new Stack[MetaData]; + val hStack = new Stack[Node]; // [ element ] contains siblings + val tagStack = new Stack[String]; + var scopeStack = new Stack[NamespaceBinding]; var curTag : String = null ; var capture:boolean = false; @@ -47,26 +48,23 @@ abstract class FactoryAdapter extends DefaultHandler() { // abstract methods /** Tests if an XML element contains text. - * @return true if element named <code>localName</code> contains text. - */ - def nodeContainsText( localName:String ):boolean ; // abstract + * @return true if element named <code>localName</code> contains text. + */ + def nodeContainsText( localName:String ):boolean ; // abstract /** creates an new non-text(tree) node. - * @param elemName - * @param attribs - * @param chIter - * @return a new XML element. - */ - def createNode(uri:String, - elemName:String , - attribs:HashMap[Pair[String,String],String] , - chIter:List[Node] ):Node; //abstract + * @param elemName + * @param attribs + * @param chIter + * @return a new XML element. + */ + def createNode(pre: String, elemName: String, attribs: MetaData, scope: NamespaceBinding, chIter: List[Node] ):Node; //abstract /** creates a Text node. * @param text * @return a new Text node. */ - def createText( text:String ):Text; // abstract + def createText( text:String ):Text[String]; // abstract // // ContentHandler methods @@ -79,7 +77,7 @@ abstract class FactoryAdapter extends DefaultHandler() { * @param offset * @param length */ - override def characters( ch:Array[char] , offset:int , length:int ):Unit = { + override def characters(ch: Array[Char], offset: Int, length: Int): Unit = { if (capture) { if( normalizeWhitespace ) { // normalizing whitespace is not compliant, but useful */ @@ -105,6 +103,8 @@ abstract class FactoryAdapter extends DefaultHandler() { } } + protected def scope() = scopeStack.top; + //var elemCount = 0; //STATISTICS /* ContentHandler methods */ @@ -113,42 +113,52 @@ abstract class FactoryAdapter extends DefaultHandler() { def startPrefixMapping( prefix:String , uri:String ):Unit = {} */ - /* Start element. */ - override def startElement(uri:String, - localName:String, - qname:String , - attributes:Attributes ):Unit = { - /*elemCount = elemCount + 1; STATISTICS */ - captureText(); - - tagStack.push(curTag); - curTag = localName ; - - capture = nodeContainsText(localName) ; - - hStack.push( null ); - var map:HashMap[Pair[String,String],String] = null:HashMap[Pair[String,String],String]; - - if (attributes == null) { - // may not happen - } - else { - map = new HashMap[Pair[String,String],String]; - - for( val i <- List.range( 0, attributes.getLength() )) { - val attrNS = attributes.getURI(i); - val attrLocalName = attributes.getLocalName(i); - val attrType = attributes.getType(i); - val attrValue = attributes.getValue(i); - // we only handle string attributes - if( attrType.equals("CDATA") ) { - map.update( Pair(attrNS,attrLocalName), attrValue ); - } - } - } - val _ = attribStack.push( map ); + /* Start element. */ + override def startElement(uri:String, _localName:String, qname:String, attributes:Attributes ):Unit = { + /*elemCount = elemCount + 1; STATISTICS */ + captureText(); + //Console.println("FactoryAdapter::startElement("+uri+","+_localName+","+qname+","+attributes+")"); + tagStack.push(curTag); + curTag = qname; //localName ; + + val colon = qname.indexOf(':'); + val localName = if(-1 == colon) qname else qname.substring(colon+1,qname.length()); + + //Console.println("FactoryAdapter::startElement - localName ="+localName); + + capture = nodeContainsText(localName) ; + + hStack.push( null ); + var m: MetaData = Null; + + var scpe = scope(); + for( val i <- List.range( 0, attributes.getLength() )) { + //val attrType = attributes.getType(i); // unused for now + val qname = attributes.getQName(i); + val value = attributes.getValue(i); + val colon = qname.indexOf(':'); + if(-1 != colon) { // prefixed attribute + val pre = qname.substring(0, colon); + val key = attributes.getLocalName(i); + if("xmlns" == pre) + scpe = value.length() match { + case 0 => new NamespaceBinding(key, null, scpe); + case _ => new NamespaceBinding(key, value, scpe); + } else + m = new PrefixedAttribute(pre, key, value, m) + } else if("xmlns" == qname) + scpe = value.length() match { + case 0 => new NamespaceBinding(null, null, scpe); + case _ => new NamespaceBinding(null, value, scpe); + } + else + m = new UnprefixedAttribute(qname, value, m) + } + scopeStack.push(scpe); + attribStack.push( m ); + {} } // startElement(String,String,String,Attributes) @@ -170,32 +180,37 @@ abstract class FactoryAdapter extends DefaultHandler() { * @param qname * @throws org.xml.sax.SAXException if .. */ - override def endElement(uri:String , localName:String , qname:String ):Unit - /*throws SAXException*/ = { + override def endElement(uri:String , _localName:String , qname:String ):Unit = { + captureText(); - captureText(); + val metaData = attribStack.pop; - val attribMap = attribStack.pop; + // reverse order to get it right + var v:List[Node] = Nil; + var child:Node = hStack.pop; + while( child != null ) { + v = child::v; + child = hStack.pop; + } - // reverse order to get it right - var v:List[Node] = Nil; - var child:Node = hStack.pop; - while( child != null ) { - v = child::v; - child = hStack.pop; - } + val colon = qname.indexOf(':'); + val localName = if(-1 == colon) qname else qname.substring(colon+1,qname.length()); - // create element - rootElem = createNode( uri, localName, attribMap, v ); - hStack.push(rootElem); + // create element + rootElem = if(-1 == colon) + createNode( null, localName, metaData, scopeStack.pop, v ); + else + createNode( qname.substring(0,colon), localName, metaData, scopeStack.pop, v ); - // set - curTag = tagStack.pop; + hStack.push(rootElem); - if (curTag != null) // root level - capture = nodeContainsText(curTag); - else - capture = false; + // set + curTag = tagStack.pop; + + if (curTag != null) // root level + capture = nodeContainsText(curTag); + else + capture = false; } // endElement(String,String,String) @@ -266,7 +281,7 @@ abstract class FactoryAdapter extends DefaultHandler() { // create parser try { val f = SAXParserFactory.newInstance(); - f.setNamespaceAware( true ); + f.setNamespaceAware( false ); parser = f.newSAXParser(); } catch { case ( e:Exception ) => { @@ -278,7 +293,9 @@ abstract class FactoryAdapter extends DefaultHandler() { // parse file try { //System.err.println("[parsing \"" + source + "\"]"); + scopeStack.push(null); parser.parse( source, this ); + scopeStack.pop; } catch { case ( e:SAXParseException ) => { // ignore diff --git a/sources/scala/xml/LoggedNodeFactory.scala b/sources/scala/xml/LoggedNodeFactory.scala index 94d8286302..e838b1b56c 100644 --- a/sources/scala/xml/LoggedNodeFactory.scala +++ b/sources/scala/xml/LoggedNodeFactory.scala @@ -37,23 +37,24 @@ with scala.util.logging.Logged { // methods of NodeFactory /** logged version of makeNode method */ - override def makeNode(uname: UName, attrSeq:AttributeSeq, children:Seq[Node]): A = { + override def makeNode(pre:String, label:String, attrSeq:MetaData, scope: NamespaceBinding, children:Seq[Node]): A = { if(logNode) - log("[makeNode for "+uname+"]"); + log("[makeNode for "+label+"]"); - val hash = Utility.hashCode(uname, attrSeq.hashCode(), children) ; + val hash = Utility.hashCode(pre, label, attrSeq.hashCode(), scope.hashCode(), children) ; + /* if(logCompressLevel >= FULL) { log("[hashcode total:"+hash); - log(" elem name "+uname+" hash "+(41 * uname.uri.hashCode() % 7 + uname.label.hashCode())); + log(" elem name "+uname+" hash "+ ? )); log(" attrs "+attrSeq+" hash "+attrSeq.hashCode()); log(" children :"+children+" hash "+children.hashCode()); } - + */ if(!cache.get( hash ).isEmpty && (logCompressLevel >= CACHE)) log("[cache hit !]"); - super.makeNode(uname, attrSeq, children); + super.makeNode(pre, label, attrSeq, scope, children); } override def makeText(s: String) = { diff --git a/sources/scala/xml/Node.scala b/sources/scala/xml/Node.scala index 9ed79afbbd..0ef443f3f6 100644 --- a/sources/scala/xml/Node.scala +++ b/sources/scala/xml/Node.scala @@ -15,7 +15,7 @@ import scala.collection.immutable; object Node { /** the constant empty attribute sequence */ - final def NoAttributes: AttributeSeq = AttributeSeq.Empty; + final def NoAttributes: MetaData = Null; /** the empty namespace */ val EmptyNamespace = ""; @@ -28,41 +28,42 @@ object Node { */ abstract class Node extends NodeSeq { - private var internalAttrMap:Map[String, String] = null; + /** prefix of this node */ + def prefix: String = null; /** label of this node. I.e. "foo" for <foo/>) */ def label: String; /** the namespace of this node */ - def namespace: String; + //final def namespace: String = scope.getURI(prefix); - /** used internally. Text = -1 PI = -2 Comment = -3 CDATA = -4 EntityRef = -5 */ + /** used internally. Text = -1 PI = -2 Comment = -3 EntityRef = -5 */ def typeTag$: Int = 0; - /** attribute map for attributes with the same namespace as this element */ - final def attribute: Map[String,String] = { - if( internalAttrMap == null ) - internalAttrMap = new Map[String,String] { - val theMap = new collection.mutable.HashMap[String,String]; - theMap ++= attributes.elements - .filter( x => x.namespace == namespace ) - .map( x => Pair(x.key, x.value) ); - - def size = - theMap.size; - - def elements = - theMap.elements; - - def get(x: String) = - theMap.get(x); - }; - internalAttrMap - } + /** the namespace bindings */ + def scope: NamespaceBinding = null; + + def namespace = getNamespace(prefix); + + def getNamespace(_pre: String) = + if(scope == null) null else scope.getURI(_pre); + + /** returns value of a MetaData instance with the same key. For + * efficiency, the namespace is not checked. + */ + final def attribute(key: String) = + attributes.getValue(key); + + /** returns value of a MetaData instance with the given namespace and the + * given key. Note that unqualified attributes have namespace null. + */ + final def attribute(uri:String, key: String) = + attributes.getValue(uri, this, key); /** attribute axis - all attributes of this node, in order defined by attrib */ - def attributes: AttributeSeq; + def attributes: MetaData = + Null; /** child axis (all children of this node) */ def child: Seq[Node]; @@ -75,18 +76,18 @@ abstract class Node extends NodeSeq { def descendant_or_self: List[Node] = this :: descendant; /** structural equality */ - override def equals(x: Any): Boolean = x match { + override def equals(x: Any): Boolean = { + x match { case that: Node => - //Console.print("(Node)"); - that.label == this.label - && that.attributes == this.attributes - && that.child.sameElements(this.child) // sameElements - case _ => false + (that.label == this.label ) + &&(that.attributes == this.attributes) + && that.child.sameElements(this.child)// sameElements + case _ => false + } } - /** returns a hashcode */ - override def hashCode(): Int = - Utility.hashCode(namespace, label, attribute.toList.hashCode(), child); + override def hashCode(): Int = 0; + //Utility.hashCode(namespace, label, attributes.hashCode(), child); /** method for NodeSeq */ @@ -106,4 +107,12 @@ abstract class Node extends NodeSeq { override def toString(): String = toString(false); + def nameToString(sb: StringBuffer): StringBuffer = { + if(null != prefix) { + sb.append(prefix); + sb.append(':'); + } + sb.append(label); + } + } diff --git a/sources/scala/xml/NodeFactory.scala b/sources/scala/xml/NodeFactory.scala index 43ee23a53c..c22ff2babd 100644 --- a/sources/scala/xml/NodeFactory.scala +++ b/sources/scala/xml/NodeFactory.scala @@ -20,10 +20,10 @@ abstract class NodeFactory[A <: Node] { /* default behaviour is to use hash-consing */ val cache = new mutable.HashMap[int,List[A]](); - protected def create(uname: UName, attrs: AttributeSeq, children:Seq[Node]): A; + protected def create(pre: String, name: String, attrs: MetaData, scope: NamespaceBinding, children:Seq[Node]): A; - protected def construct(hash:Int, old:List[A], uname: UName, attrSeq:AttributeSeq, children:Seq[Node]): A = { - val el = create(uname, attrSeq, children); + protected def construct(hash:Int, old:List[A], pre: String, name: String, attrSeq:MetaData, scope: NamespaceBinding, children:Seq[Node]): A = { + val el = create(pre, name, attrSeq, scope, children); cache.update( hash, el::old ); el } @@ -41,25 +41,27 @@ abstract class NodeFactory[A <: Node] { } } - def nodeEquals(n: Node, uname: UName, attrSeq:AttributeSeq, children:Seq[Node]) = - (n.namespace == uname.uri) - &&(n.label == uname.label) + def nodeEquals(n: Node, pre: String, name: String, attrSeq:MetaData, scope: NamespaceBinding, children:Seq[Node]) = + (n.prefix == pre) + &&(n.label == name) &&(n.attributes == attrSeq) + // scope?? &&(eqElements(n.child,children)); - def makeNode(uname: UName, attrSeq:AttributeSeq, children:Seq[Node]): A = { - val hash = Utility.hashCode( uname, attrSeq.hashCode(), children ) ; + def makeNode(pre: String, name: String, attrSeq:MetaData, scpe: NamespaceBinding, children:Seq[Node]): A = { + //Console.println("NodeFactory::makeNode("+pre+","+name+","+attrSeq+","+scpe+","+children+")"); + val hash = Utility.hashCode( pre, name, attrSeq.hashCode(), scpe.hashCode(), children ) ; cache.get( hash ) match { case Some(list) => // find structurally equal val it = list.elements; - val lookup = it.find { x => nodeEquals(x,uname,attrSeq,children) }; + val lookup = it.find { x => nodeEquals(x, pre, name, attrSeq, scpe, children) }; lookup match { case Some(x) => //Console.println("[cache hit !]"+x); x; // return cached elem - case _ => construct(hash, list, uname, attrSeq, children); + case _ => construct(hash, list, pre, name, attrSeq, scpe, children); } - case _ => construct(hash, Nil, uname, attrSeq, children) + case _ => construct(hash, Nil, pre, name, attrSeq, scpe, children) } } diff --git a/sources/scala/xml/NodeTraverser.scala b/sources/scala/xml/NodeTraverser.scala index f70a684d8d..052219ceae 100644 --- a/sources/scala/xml/NodeTraverser.scala +++ b/sources/scala/xml/NodeTraverser.scala @@ -24,7 +24,7 @@ class NodeTraverser[A <: AnyRef](handle: parsing.MarkupHandler[A]) { while(it.hasNext) { nb.appendAll(traverse(it.next)); } - handle.element(0, n.namespace, n.label, n.attributes.toMap, nb) + handle.element(0, n.namespace, n.label, n.attributes, nb) } } diff --git a/sources/scala/xml/PrettyPrinter.scala b/sources/scala/xml/PrettyPrinter.scala index 0b1e233481..7901c7c8ab 100644 --- a/sources/scala/xml/PrettyPrinter.scala +++ b/sources/scala/xml/PrettyPrinter.scala @@ -34,7 +34,7 @@ class PrettyPrinter( width:Int, step:Int ) { protected var items:List[Item] = Nil; protected var cur = 0; - protected var pmap:Map[String,String] = _; + //protected var pmap:Map[String,String] = _; protected def reset() = { cur = 0; @@ -96,58 +96,132 @@ class PrettyPrinter( width:Int, step:Int ) { protected def leafTag( n:Node ) = { val sb = new StringBuffer("<"); - Utility.appendPrefixedName( n.namespace, n.label, pmap, sb ); - Utility.attr2xml( n.namespace, n.attributes.elements, pmap, sb ); + n.nameToString(sb); + //Utility.appendPrefixedName( n.prefix, n.label, pmap, sb ); + n.attributes.toString(sb); + //Utility.attr2xml( n.scope, n.attributes, pmap, sb ); sb.append("/>"); sb.toString(); } - protected def rootStartTag(n: Node) = { + protected def startTag(n: Node, pscope: NamespaceBinding): Pair[String, Int] = { val sb = new StringBuffer("<"); - Utility.appendPrefixedName( n.namespace, n.label, pmap, sb ); - Utility.attr2xml( n.namespace, n.attributes.elements, pmap, sb ); - if(( pmap.size != 1 )|| !pmap.contains("")) - for( val c <- pmap.elements; c._2 != "xml" ) { - sb.append(" xmlns:"); - sb.append(c._2); - sb.append("=\""); - sb.append(c._1); - sb.append('"'); + n.nameToString(sb); //Utility.appendPrefixedName( n.prefix, n.label, pmap, sb ); + val i = sb.length() + 1; + n.attributes.toString(sb); + var scp = n.scope; + while( scp != TopScope && !scp.eq(pscope)) { + sb.append(' '); + sb.append("xmlns"); + if(scp.prefix != null) { + sb.append(':'); + sb.append(scp.prefix); } + sb.append("=\""); + if(scp.uri != null) sb.append(scp.uri); + sb.append('\"'); + scp = scp.parent; + } + + //Utility.attr2xml( n.namespace, n.attributes, pmap, sb ); sb.append('>'); - sb.toString(); - } - protected def startTag(n: Node) = { - val sb = new StringBuffer("<"); - Utility.appendPrefixedName( n.namespace, n.label, pmap, sb ); - Utility.attr2xml( n.namespace, n.attributes.elements, pmap, sb ); - sb.append('>'); - sb.toString(); + Pair(sb.toString(), i); } protected def endTag(n: Node) = { val sb = new StringBuffer("</"); - Utility.appendPrefixedName( n.namespace, n.label, pmap, sb ); + n.nameToString(sb); //Utility.appendPrefixedName( n.prefix, n.label, pmap, sb ); sb.append('>'); sb.toString(); } + + protected def breakable( n:Node ):boolean = { + val it = n.child.elements; + while( it.hasNext ) + it.next match { + case _:Text[Any] | _:Comment | _:EntityRef | _:ProcInstr => + case _:Node => return true; + } + return false + } + /** @param tail: what we'd like to sqeeze in */ + protected def traverse( node:Node, pscope: NamespaceBinding, ind:int ):Unit = { + node match { + + case _:Text[Any] | _:Comment | _:EntityRef | _:ProcInstr => + makeBox( ind, node.toString() ); + + case _:Node => + val sb = new StringBuffer(); + val test = { Utility.toXML(node, pscope, sb, false); sb.toString()}; + if(( test.length() < width - cur )&&( !breakable( node ))){ // all ? + makeBox( ind, test ); + } else { // start tag + content + end tag + //Console.println(node.label+" ind="+ind); + val Pair(stg, len2) = startTag( node, pscope ); + val etg = endTag( node ); + //val len2 = pmap(node.namespace).length() + node.label.length() + 2; + + if( stg.length() < width - cur ) { // start tag fits + + makeBox( ind, stg ); + makeBreak(); + traverse( node.child.elements, node.scope, ind + step ); + makeBox( ind, etg ); + + } else if( len2 < width - cur ) { + // <start label + attrs + tag + content + end tag + makeBox( ind, stg.substring( 0, len2 )); + makeBreak(); // todo: break the rest in pieces + /*{ //@todo + val sq:Seq[String] = stg.split(" "); + val it = sq.elements; + it.next; + for( val c <- it ) { + makeBox( ind+len2-2, c ); + makeBreak(); + } + }*/ + makeBox( ind, stg.substring( len2, stg.length() )); + makeBreak(); + traverse( node.child.elements, node.scope, ind + step ); + makeBox( cur, etg ); + } else { // give up + makeBox( ind, test ); + makeBreak(); + } + } + } + } + + protected def traverse( it:Iterator[Node], scope:NamespaceBinding, ind:int ):unit = { + for( val c <- it ) { + traverse( c, scope, ind ); + makeBreak(); + } + } + /** appends a formatted string containing well-formed XML with * given namespace to prefix mapping to the given stringbuffer * @param n the node to be serialized * @param pmap the namespace to prefix mapping * @param sb the stringbuffer to append to */ - def format(n: Node, pmap: Map[String,String], sb: StringBuffer ): Unit = { + def format(n: Node, sb: StringBuffer ): Unit = { // entry point + format(n,null,sb) + } + + def format(n: Node, pscope:NamespaceBinding, sb: StringBuffer): Unit = { // entry point reset(); - this.pmap = pmap; - traverse1( n, 0 ); + traverse( n, pscope, 0 ); var cur = 0; //Console.println( items.reverse ); for( val b <- items.reverse ) b match { case Break => sb.append('\n'); // on windows: \r\n ? cur = 0; + case Box(i, s) => while( cur < i ) { sb.append(' '); @@ -159,170 +233,39 @@ class PrettyPrinter( width:Int, step:Int ) { } } - protected def breakable( n:Node ):boolean = { - val it = n.child.elements; - while( it.hasNext ) - it.next match { - case _:Text | _:Comment | _:EntityRef | _:ProcInstr => - case _:Node => return true; - } - return false - } - /** @param tail: what we'd like to sqeeze in */ - protected def traverse( node:Node, ind:int ):Unit = { - node match { - - case _:Text | _:Comment | _:EntityRef | _:ProcInstr => - makeBox( ind, node.toString() ); - - case _:Node => - val sb = new StringBuffer(); - val test = { Utility.toXML1(node,pmap,sb); sb.toString()}; - if(( test.length() < width - cur )&&( !breakable( node ))){ // all ? - makeBox( ind, test ); - } else { // start tag + content + end tag - //Console.println(node.label+" ind="+ind); - val stg = startTag( node ); - val etg = endTag( node ); - val len2 = pmap(node.namespace).length() + node.label.length() + 2; - - if( stg.length() < width - cur ) { // start tag fits - - makeBox( ind, stg ); - makeBreak(); - traverse( node.child.elements, ind + step ); - makeBox( ind, etg ); - - } else if( len2 < width - cur ) { - // <start label + attrs + tag + content + end tag - makeBox( ind, stg.substring( 0, len2 )); - makeBreak(); - /*{ //@todo - val sq:Seq[String] = stg.split(" "); - val it = sq.elements; - it.next; - for( val c <- it ) { - makeBox( ind+len2-2, c ); - makeBreak(); - } - }*/ - makeBox( ind, stg.substring( len2, stg.length() )); - makeBreak(); - traverse( node.child.elements, ind + step ); - makeBox( cur, etg ); - } else { - makeBox( ind, test ); - makeBreak(); - } - } - } - } - - /** @param tail: what we'd like to sqeeze in */ - protected def traverse1( node:Node, ind:int ):Unit = { - node match { - - case _:Text | _:Comment | _:EntityRef | _:ProcInstr => - makeBox( ind, node.toString() ); - - case _:Node => { - // start tag + content + end tag - //Console.println(node.label+" ind="+ind); - val stg = rootStartTag( node ); - val etg = endTag( node ); - val len2 = pmap(node.namespace).length() +node.label.length() + 2; - - if( stg.length() < width - cur ) { // start tag fits - - makeBox( ind, stg ); - makeBreak(); - traverse( node.child.elements, ind + step ); - makeBox( ind, etg ); - - } else if( len2 < width - cur ) { - val sq:Seq[String] = stg.split(" "); - val it = sq.elements; - var tmp = it.next; - makeBox( ind, tmp ); - var curlen = cur + tmp.length(); - while( it.hasNext ) { - var tmp = it.next; - if( tmp.length() + curlen + 1 < width ) { - makeBox( ind, " " ); - makeBox( ind, tmp ); - curlen = curlen + tmp.length() + 1; - } else { - makeBreak(); - makeBox( len2+1, tmp ); - curlen = len2+1; - } - } - // <start label + attrs + tag + content + end tag - //makeBox( ind, stg.substring( 0, len2 )); - //makeBreak(); - /*{ //@todo - val sq:Seq[String] = stg.split(" "); - val it = sq.elements; - it.next; - for( val c <- it ) { - makeBox( ind+len2-2, c ); - makeBreak(); - } - }*/ - //makeBox( ind, stg.substring( len2, stg.length() )); - makeBreak(); - traverse( node.child.elements, ind + step ); - makeBox( cur, etg ); - } else { // it does not fit, dump everything - val sb = new StringBuffer(); - val tmp = { Utility.toXML1(node,pmap,sb); sb.toString()}; - makeBox( ind, tmp ); - makeBreak(); - } - } - } - } - - protected def traverse( it:Iterator[Node], ind:int ):unit = { - for( val c <- it ) { - traverse( c, ind ); - makeBreak(); - } - } - // public convenience methods /** returns a formatted string containing well-formed XML with * default namespace prefix mapping * @param n the node to be serialized */ - def format(n: Node): String = format(n, Utility.defaultPrefixes( n )); + def format(n: Node): String = format(n, null); //Utility.defaultPrefixes( n )); /** returns a formatted string containing well-formed XML with * given namespace to prefix mapping * @param n the node to be serialized * @param pmap the namespace to prefix mapping */ - def format(n: Node, pmap: Map[String,String]): String = { + def format(n: Node, pscope: NamespaceBinding): String = { val sb = new StringBuffer(); - format( n, pmap, sb ); + format( n, pscope, sb ); sb.toString(); } /* returns a formatted string containing well-formed XML nodes with * default namespace prefix mapping */ - def format( nodes:Seq[Node] ):String = { - format(nodes, Utility.defaultPrefixes( nodes )) + def formatNodes( nodes:Seq[Node] ):String = { + formatNodes(nodes, null) } /** returns a formatted string containing well-formed XML * @param nodes the sequence of nodes to be serialized * @param pmap the namespace to prefix mapping */ - def format( nodes:Seq[Node], pmap:Map[String,String] ):String = { + def formatNodes( nodes:Seq[Node], pscope: NamespaceBinding ):String = { var sb = new StringBuffer(); - format( nodes, pmap, sb ); + formatNodes( nodes, pscope, sb ); sb.toString(); } @@ -332,8 +275,9 @@ class PrettyPrinter( width:Int, step:Int ) { * @param pmap the namespace to prefix mapping * @param sb the string buffer to which to append to */ - def format( nodes: Seq[Node], pmap: Map[String,String], sb: StringBuffer ): Unit = { for( val n <- nodes.elements ) { - sb.append(format( n, pmap )) + def formatNodes( nodes: Seq[Node], pscope: NamespaceBinding, sb: StringBuffer ): Unit = { + for( val n <- nodes.elements ) { + sb.append(format( n, pscope )) } } } diff --git a/sources/scala/xml/SpecialNode.scala b/sources/scala/xml/SpecialNode.scala index 974ee4ddd9..9752400fd5 100644 --- a/sources/scala/xml/SpecialNode.scala +++ b/sources/scala/xml/SpecialNode.scala @@ -15,10 +15,10 @@ package scala.xml; abstract class SpecialNode extends Node { /** always Node.EmptyNamespace */ - final def namespace = Node.EmptyNamespace; + //final def namespace = Node.EmptyNamespace; - /** always empty */ - final def attributes = Node.NoAttributes; + /** always empty */ + //final def attributes = Node.NoAttributes; /** always empty */ final def child = Nil; diff --git a/sources/scala/xml/Text.scala b/sources/scala/xml/Text.scala index 1671bdbf79..bb0e32a375 100644 --- a/sources/scala/xml/Text.scala +++ b/sources/scala/xml/Text.scala @@ -16,9 +16,14 @@ import scala.collection.immutable ; * @param text the text contained in this node, may not be null. **/ -case class Text( text:String ) extends SpecialNode { - if(null == text) +case class Text[A]( data: A ) extends SpecialNode { + + /** @deprecated + */ + def text = toString(); + + if(null == data) throw new java.lang.NullPointerException("tried to construct Text with null"); final override def typeTag$:Int = -1; @@ -28,15 +33,15 @@ case class Text( text:String ) extends SpecialNode { def label = "#PCDATA"; final override def equals(x:Any) = x match { - case s:String => text.equals( s ); - case Text( s ) => text.equals( s ); + case s:String => s.equals( data.toString() ); + case Text( s ) => data == s ; case _ => false; } /** hashcode for this Text */ - override def hashCode() = text.hashCode(); + override def hashCode() = data.hashCode(); /** returns text, with some characters escaped according to XML spec */ - override def toString() = Utility.escape( text ); + override def toString() = Utility.escape( data.toString() ); } diff --git a/sources/scala/xml/TextBuffer.scala b/sources/scala/xml/TextBuffer.scala index ff528cf3d2..ee89bef6da 100644 --- a/sources/scala/xml/TextBuffer.scala +++ b/sources/scala/xml/TextBuffer.scala @@ -39,7 +39,7 @@ class TextBuffer { } /** returns an empty sequence if text is only whitespace */ - def toText:Seq[Text] = { + def toText:Seq[Text[String]] = { var len = sb.length(); /* invariant */ if( len == 0 ) return Nil; diff --git a/sources/scala/xml/Utility.scala b/sources/scala/xml/Utility.scala index 03a26b1d37..cc6d50589c 100644 --- a/sources/scala/xml/Utility.scala +++ b/sources/scala/xml/Utility.scala @@ -20,7 +20,7 @@ import scala.collection.Map; */ object Utility { - def view(s: String): Text = Text(s); + def view(s: String): Text[String] = Text(s); /* escapes the characters < > & and " from string */ def escape(text: String) = { @@ -40,17 +40,16 @@ object Utility { * descendants, including the empty namespaces * * @param node - */ def collectNamespaces(node: Node): mutable.Set[String] = { collectNamespaces(node, new mutable.HashSet[String]()); } + */ /** * Returns a set of all namespaces appearing in a sequence of nodes * and all their descendants, including the empty namespaces * * @param nodes - */ def collectNamespaces(nodes: Seq[Node]): mutable.Set[String] = { var m = new mutable.HashSet[String](); for (val n <- nodes) @@ -61,10 +60,13 @@ object Utility { private def collectNamespaces(node: Node, set: mutable.Set[String]): mutable.Set[String] = { def collect( n:Node ):Unit = { if( n.typeTag$ >= 0 ) { - set += n.namespace; /* namespaces are interned, so hashing is fast */ + set += n.namespace; for (val a <- n.attributes) - if (a.namespace.length() > 0) // == 0 should not happen, but safer. - set += a.namespace; + a.match { + case _:PrefixedAttribute => + set += a.getNamespace(n) + case _ => + } for (val i <- n.child) collect(i); } @@ -72,6 +74,7 @@ object Utility { collect(node); set } + */ /** * A prefix mapping that maps the empty namespace to the empty prefix @@ -85,7 +88,6 @@ object Utility { * * @param rootns * @param nset - */ def defaultPrefixes(rootns: String, nset: mutable.Set[String]): Map[String,String] = { val map = new mutable.HashMap[String,String](); if (nset.contains("http://www.w3.org/XML/1998/namespace")) @@ -101,22 +103,34 @@ object Utility { // Console.println("defaultPrefixes:"+map); // DEBUG return map; } + */ /** * @see "defaultPrefixes(String, mutable.Set[String])" - */ def defaultPrefixes(n: Node): Map[String,String] = defaultPrefixes(n.namespace, collectNamespaces( n )); + */ /** * @see "defaultPrefixes(String, mutable.Set[String])" - */ def defaultPrefixes(nodes: Seq[Node]): Map[String,String] = defaultPrefixes("", collectNamespaces(nodes)); + */ + def scope2map(n:NamespaceBinding): immutable.Map[String,String] = + scope2map(n, immutable.ListMap.Empty[String,String]); - /** + def scope2map(n:NamespaceBinding, map:immutable.Map[String,String]): immutable.Map[String,String] = { + if(TopScope == n) + map + else if(null == n.uri) + scope2map(n.parent, map - n.prefix) + else + scope2map(n.parent, map.update(n.prefix, n.uri)) + } + + /** string representation of an XML node, with comments stripped the comments * @see "toXML(Node, Boolean)" */ def toXML(n: Node): String = toXML(n, true); @@ -131,16 +145,16 @@ object Utility { * @todo define a way to escape literal characters to &xx; references */ def toXML(n: Node, stripComment: Boolean): String = { - val s = new StringBuffer(); - toXML(n, defaultPrefixes(n), s, stripComment); - s.toString(); + val sb = new StringBuffer(); + toXML(n, null, sb, stripComment); + sb.toString(); } /** * @see "toXML(Node, Map[String,String], Boolean)" - */ def toXML(x: Node, pmap: Map[String,String]): String = toXML(x, pmap, false); + */ /** * Serializes a node with given namespace prefix mapping. The prefix @@ -149,32 +163,35 @@ object Utility { * @param x the node to serialize * @param pmap a mapping from namespace URIs to prefixes * @param stripComment - */ def toXML(x: Node, pmap: Map[String,String], stripComment: Boolean): String = { val sb = new StringBuffer(); toXML(x, pmap, sb, stripComment); sb.toString(); } + */ /** * @see "toXML(Node, Map[String,String], StringBuffer, Boolean)" - */ def toXML(x: Node, pmap: Map[String,String], sb: StringBuffer): Unit = toXML(x, pmap, sb, false); + */ /** serializes a tree to the given stringbuffer * with the given namespace prefix mapping. * elements and attributes that have namespaces not in pmap are <strong>ignored</strong> - * @param n the root node - * @param pmap mapping namespaces to prefixes + * @param n the node + * @param pscope the parent scope * @param sb stringbuffer to append to * @param stripComment if true, strip comments */ - def toXML(x: Node, pmap: Map[String,String], sb: StringBuffer, stripComment: Boolean): Unit = { + def toXML(x: Node, pscope: NamespaceBinding, sb: StringBuffer, stripComment: Boolean): Unit = { + //Console.println("inside toXML, x.label = "+x.label); + //Console.println("inside toXML, x.scope = "+x.scope); + //Console.println("inside toXML, pscope = "+pscope); x match { case Text(t) => - sb.append(escape(t)); + sb.append(escape(t.toString())); case Comment(text) => if (!stripComment) { @@ -186,114 +203,68 @@ object Utility { case _ if x.typeTag$ < 0 => sb.append( x.toString() ); - case _ if( pmap.contains( x.namespace )) => { + case _ => { // print tag with namespace declarations sb.append('<'); - appendPrefixedName( x.namespace, x.label, pmap, sb ); - if (x.attributes.length != 0) { - attr2xml( x.namespace, x.attributes.elements, pmap, sb ) + x.nameToString(sb); //appendPrefixedName( x.prefix, x.label, pmap, sb ); + if (x.attributes != null) { + x.attributes.toString(sb) } - if ((pmap.size != 1) || pmap.get("").isEmpty) { - for (val Pair(ns, pref) <- pmap.elements; pref!="xml") { - sb.append(' '); - sb.append("xmlns"); - if(pref.length() > 0) sb.append(':'); - sb.append(pref); - sb.append("=\""); - sb.append(ns); - sb.append('"') + var scp = x.scope; + while( scp != null && !scp.eq(pscope)) { + sb.append(' '); + sb.append("xmlns"); + if(scp.prefix != null) { + sb.append(':'); + sb.append(scp.prefix); } + sb.append("=\""); + if(scp.uri != null) sb.append(scp.uri); + sb.append('\"'); + scp = scp.parent; } sb.append('>'); for (val c <- x.child.elements) { - toXML1(c, pmap, sb, stripComment); + toXML(c, x.scope, sb, stripComment); } sb.append("</"); - appendPrefixedName(x.namespace, x.label, pmap, sb); + x.nameToString(sb); //appendPrefixedName(x.prefix, x.label, pmap, sb); sb.append('>') } } } - /** - * Serializes a non-root node to the given stringbuffer - * with the given namespace prefix mapping. use toXML to print the - * root node, which will have namespace declarations. - * - * @param n the non-root node - * @param pmap mapping namespaces to prefixes - * @param sb stringbuffer to append to - * @param stripComment if true, strip comments - */ - def toXML1(x: Node, pmap: Map[String,String], sb: StringBuffer, stripComment: Boolean): Unit = { - //Console.print("toString: "+x.toString()); - x match { - case Text(t) => - sb.append(escape(t)); - - case Comment(text) => - if (!stripComment) { - sb.append("<!--"); - sb.append(text); - sb.append("-->"); - } - - case _ if x.typeTag$ < 0 => - sb.append( x.toString() ); - case _ if( pmap.contains( x.namespace )) => { - sb.append('<'); - appendPrefixedName(x.namespace, x.label, pmap, sb); - if (x.attributes.length != 0) { - attr2xml(x.namespace, x.attributes.elements, pmap, sb) - } - sb.append('>'); - for (val c <- x.child.elements) { - toXML1(c, pmap, sb, stripComment); - } - sb.append("</"); - appendPrefixedName(x.namespace, x.label, pmap, sb); - sb.append('>'); - } - } + /** returns prefix of qualified name if any */ + final def prefix(name: String): Option[String] = { + val i = name.indexOf(':'); + if( i != -1 ) Some( name.substring(0, i) ) else None } /** - * @see "toXML1(Node, Map[String,String], StringBuffer, Boolean)" - */ - def toXML1(x: Node, pmap: Map[String,String], sb: StringBuffer): Unit = - toXML1(x, pmap, sb, false); - - /** * For a Node n, returns string representation of <code>n.attributes</code> * * @param ns * @param attrib * @param pmap * @param sb - */ - def attr2xml(ns: String, attrib: Iterator[Attribute], pmap: Map[String, String], sb: StringBuffer ) = { - for (val x <- attrib) { + def attr2xml(attrib: Iterator[MetaData], sb: StringBuffer ) = { + val md = attrib; + while(null != md) { sb.append(' '); - if (ns == x.namespace) - sb.append(x.key); - else - appendPrefixedName(x.namespace, x.key, pmap, sb); - sb.append("="); - appendQuoted(x.value, sb) - } + md.match { + case _:UnprefixedAttribute => + sb.append(x.key); + case p:PrefixedAttribute => + sb.append(p.pre); + sb.append(':'); + sb.append(x.key); + } + sb.append("="); + appendQuoted(x.value, sb) + } } - - /** - * Returns a hashcode for the given constituents of a node - * - * @param uname - * @param attribHashCode - * @param children */ - def hashCode(uname: UName, attribHashCode: Int, children: Seq[Node]): Int = { - hashCode(uname.uri, uname.label, attribHashCode, children); - } /** * Returns a hashcode for the given constituents of a node @@ -303,8 +274,8 @@ object Utility { * @param attribHashCode * @param children */ - def hashCode(uri: String, label: String, attribHashCode: Int, children: Seq[Node]) = { - 41 * uri.hashCode() % 7 + label.hashCode() + attribHashCode + children.hashCode() + def hashCode(pre: String, label: String, attribHashCode: Int, scpeHash: Int, children: Seq[Node]) = { + 41 * pre.hashCode() % 7 + label.hashCode() * 53 + attribHashCode * 7 + scpeHash * 31 + children.hashCode() } /** @@ -314,10 +285,10 @@ object Utility { * @param label * @param attribs * @param children - */ - def hashCode(uri: String, label: String, attribs: scala.collection.mutable.HashMap[Pair[String,String],String], children: Seq[Node]): Int = { - 41 * uri.hashCode() % 7 + label.hashCode() + attribs.toList.hashCode() + children.hashCode() + def hashCode(uri: String, label: String, attribs: scala.collection.mutable.HashMap[Pair[String,String],String], scpe: Int, children: Seq[Node]): Int = { + 41 * uri.hashCode() % 7 + label.hashCode() + attribs.toList.hashCode() + scpe + children.hashCode() } + */ def systemLiteralToString(s: String) = { val sb = new StringBuffer("SYSTEM "); @@ -341,15 +312,15 @@ object Utility { * @param name * @param pmap * @param sb - */ - def appendPrefixedName(ns: String, name: String, pmap: Map[String, String], sb: StringBuffer): Unit = { - val pref = pmap( ns ); + def appendPrefixedName(pref: String, name: String, pmap: Map[String, String], sb: StringBuffer): Unit = { + //val pref = pmap( ns ); if (pref.length() > 0) { sb.append(pref); sb.append(':') } sb.append(name) } + */ /** * Appends "s" if s does not contain ", 's' @@ -379,5 +350,4 @@ object Utility { sb.append('"') } - } diff --git a/sources/scala/xml/dtd/Validation.scala b/sources/scala/xml/dtd/Validation.scala index 604debd988..2750b269ba 100644 --- a/sources/scala/xml/dtd/Validation.scala +++ b/sources/scala/xml/dtd/Validation.scala @@ -43,7 +43,7 @@ class ElementValidator(namespace$$: String, elemSpec: RegExp) { val it = s.elements; while( it.hasNext ) { val n = it.next; - if(( n.namespace == namespace )&& !set.contains( n.label )) + //if(( n.namespace == namespace )&& !set.contains( n.label )) // todo throw MakeValidationException.fromUndefinedElement( n.label ); } } diff --git a/sources/scala/xml/nobinding/NoBindingFactoryAdapter.scala b/sources/scala/xml/nobinding/NoBindingFactoryAdapter.scala index 63a6b363dc..25563f8ecc 100644 --- a/sources/scala/xml/nobinding/NoBindingFactoryAdapter.scala +++ b/sources/scala/xml/nobinding/NoBindingFactoryAdapter.scala @@ -16,6 +16,7 @@ import org.xml.sax.InputSource; */ class NoBindingFactoryAdapter extends FactoryAdapter with NodeFactory[Elem] { + // FactoryAdapter methods /** returns true. Every XML node may contain text that the application needs @@ -24,33 +25,25 @@ class NoBindingFactoryAdapter extends FactoryAdapter with NodeFactory[Elem] { // methods for NodeFactory[Elem] - protected def create(uname: UName, attrs: AttributeSeq, children:Seq[Node]): Elem = { - Elem( uname.uri, uname.label, attrs, children:_* ); + protected def create(pre: String, label: String, attrs: MetaData, scpe: NamespaceBinding, children:Seq[Node]): Elem = { + Elem( pre, label, attrs, scpe, children:_* ); } // methods for FactoryAdapter /** creates a node. never creates the same node twice, using hash-consing */ - def createNode(uri:String, label: String, attrs: mutable.HashMap[Pair[String,String],String], children: List[Node] ): Elem = { + def createNode(pre:String, label: String, attrs: MetaData, scpe: NamespaceBinding, children: List[Node] ): Elem = { + //Console.println("NoBindingFactoryAdapter::createNode("+pre+","+label+","+attrs+","+scpe+","+children+")"); + Elem( pre, label, attrs, scpe, children:_* ); - // this is a dirty hack to quickly add xmlns. - // does SAX handle prefixes, xmlns stuff ? - val defNS = getDefaultNamespace( attrs.keys ); - var uri$:String = if(( defNS.length() > 0 )&&( uri.length == 0 )) { - defNS - } else { - uri.intern(); - } - val attrSeq = AttributeSeq.fromMap( uri$, attrs ); - val elHashCode = - Utility.hashCode( uri$, label, attrSeq.hashCode(), children ) ; - makeNode(UName(uri$,label),attrSeq, children); + //makeNode(pre, label, attrs, scope, children); } /** creates a text node */ - def createText( text:String ) = Text( text ); + def createText( text:String ) = + Text( text ); /** loads an XML document, returning a Symbol node. */ diff --git a/sources/scala/xml/parsing/ConstructingHandler.scala b/sources/scala/xml/parsing/ConstructingHandler.scala index 7fbb48b878..e62617f933 100644 --- a/sources/scala/xml/parsing/ConstructingHandler.scala +++ b/sources/scala/xml/parsing/ConstructingHandler.scala @@ -1,45 +1,11 @@ package scala.xml.parsing; -import scala.collection.Map ; -import scala.collection.mutable ; - -/** */ -class ConstructingHandler extends MarkupHandler[Node] { - - //def attributeCDataValue(pos: int, str:String) = CDataValue(str); - - //def attributeNamespaceDecl(pos: int, uri: String) = NamespaceDecl(uri); - - def element(pos: int, uri: String, label: String, attrMap1: Map[Pair[String,String],Attribute], args: mutable.Buffer[Node]):Iterable[Node] = { - - var attrs = new Array[Attribute](attrMap1.size); - { - var i = 0; - val it = attrMap1.elements; - while( it.hasNext ) { - val Pair(Pair(uri:String, key:String), va: Attribute) = it.next; - attrs( i ) = va; - /* - va match { - case CDataValue(str) => attrs( i ) = Attribute(uri, key, str); - } - */ - i = i + 1; - } - } - val attrSeq: Seq[Attribute] = attrs; - val nodes = new Array[Node]( args.length ); - { - var i = 0; - val it = args.elements; - while( i < args.length ) { - nodes(i) = it.next; - i = i + 1; - } - } - val ch: Seq[Node] = nodes; - Some(Elem(uri, label, AttributeSeq.fromAttrs(uri,attrSeq:_*), ch:_*)); - }; +/** implementation of MarkupHandler that constructs nodes */ +class ConstructingHandler extends MarkupHandler { + + def element(pos: int, pre: String, label: String, attrs: MetaData, pscope: NamespaceBinding, nodes: NodeSeq): NodeSeq = + Elem(pre, label, attrs, pscope, nodes:_*); + def procInstr(pos: Int, target: String, txt: String ) = ProcInstr(target, txt); diff --git a/sources/scala/xml/parsing/ConstructingParser.scala b/sources/scala/xml/parsing/ConstructingParser.scala index 99b20b0225..f6d3216963 100644 --- a/sources/scala/xml/parsing/ConstructingParser.scala +++ b/sources/scala/xml/parsing/ConstructingParser.scala @@ -26,7 +26,7 @@ object ConstructingParser { /** an xml parser. parses XML and invokes callback methods of a MarkupHandler */ -abstract class ConstructingParser extends MarkupParser[Node] { +abstract class ConstructingParser extends MarkupParser { val handle = new ConstructingHandler(); diff --git a/sources/scala/xml/parsing/MarkupHandler.scala b/sources/scala/xml/parsing/MarkupHandler.scala index cf6f9286c1..c1e5fa7c2e 100644 --- a/sources/scala/xml/parsing/MarkupHandler.scala +++ b/sources/scala/xml/parsing/MarkupHandler.scala @@ -5,65 +5,32 @@ import scala.collection.mutable ; import scala.collection.Map ; /** class that handles markup - provides callback methods to MarkupParser */ -abstract class MarkupHandler[A <: AnyRef] { +abstract class MarkupHandler { - /** a stack of prefix namespace mappings */ - protected val prefixStack = - new mutable.Stack[immutable.Map[String,String]](); - - /** mapping from prefixes to namespaces */ + /** mapping from prefixes to namespaces var namespace: immutable.Map[String,String] = new immutable.TreeMap[String,String] .update("","") .update("xml","http://www.w3.org/XML/1998/namespace"); + */ - - var tmpPrefix: mutable.Map[String, String] = - new mutable.HashMap[String,String]; - - /** returns prefix of the qualified name if any */ - final def namespacePrefix(name: String): Option[String] = { - val i = name.indexOf(':'); - if( i != -1 ) Some( name.substring(0, i) ) else None - } - - /** removes xmlns attributes from attr as a side effect, and returns a prefix - * map resulting from them - */ - final def internal_namespaceDecl(prefix:String, uri:String): Unit = { - tmpPrefix.update(prefix, uri); - } - - //def attributeCDataValue(pos: int, str:String): Attribute; - //def attributeNamespaceDecl(pos: int, uri: String): Attribute; - - def attribute(pos: int, uri: String, key: String, value:String) = - Attribute(uri,key,value); - - /** be careful to copy everything from attrMap1, as it will change + /** callback method that is invoked by MarkupParser after fully + * parsing element fully. + * * @param pos the position in the sourcefile - * @param uri the namespace uri - * @param label the tag name - * @param attrMap1 the attribute map, from Pair(uri,label) to target + * @param pre the prefix + * @param label the local name + * @param attrs the attributes (metadata) * @param args the children of this element */ - def element(pos: int, uri: String, label: String, attrMap1: Map[Pair[String,String],Attribute], args: mutable.Buffer[A]): Iterable[A]; - - def procInstr(pos: Int, target: String, txt: String): Iterable[A]; - def comment(pos: Int, comment: String ): Iterable[A]; - def entityRef(pos: Int, n: String): Iterable[A]; + def element(pos: int, pre: String, label: String, attrs: MetaData, scope:NamespaceBinding, args: NodeSeq): NodeSeq; - def text(pos: Int, txt:String): Iterable[A]; + def procInstr(pos: Int, target: String, txt: String): NodeSeq; + def comment(pos: Int, comment: String ): NodeSeq; - def internal_startPrefixMapping: Unit = { - this.prefixStack.push( this.namespace ); - this.namespace = this.namespace incl tmpPrefix; - tmpPrefix.clear; - } + def entityRef(pos: Int, n: String): NodeSeq; - def internal_endPrefixMapping: Unit = { - this.namespace = prefixStack.pop; - } + def text(pos: Int, txt:String): NodeSeq; } diff --git a/sources/scala/xml/parsing/MarkupParser.scala b/sources/scala/xml/parsing/MarkupParser.scala index c2bbf42338..33668bbd55 100644 --- a/sources/scala/xml/parsing/MarkupParser.scala +++ b/sources/scala/xml/parsing/MarkupParser.scala @@ -9,18 +9,14 @@ package scala.xml.parsing; -import scala.xml.Attribute; -import scala.collection.{ mutable, Map }; -import scala.collection.immutable.ListMap; - /** an xml parser. parses XML, invokes callback methods of a MarkupHandler * and returns whatever the markup handler returns. Use ConstructingParser * if you just want to parse XML to construct instances of scala.xml.Node. */ -abstract class MarkupParser[MarkupType <: AnyRef] { +abstract class MarkupParser { /** the handler of the markup */ - val handle: MarkupHandler[MarkupType]; + val handle: MarkupHandler; /** if true, does not remove surplus whitespace */ val preserveWS: Boolean; @@ -40,15 +36,8 @@ abstract class MarkupParser[MarkupType <: AnyRef] { /** append Unicode character to name buffer*/ protected def putChar(c: Char) = cbuf.append(c); - protected var aMap: mutable.Map[String,Attribute] = _; - - final val noChildren = new mutable.ListBuffer[MarkupType]; - final val noAttribs = new mutable.HashMap[Pair[String,String], Attribute]; - //var xEmbeddedBlock = false; - var defaultURI: String = ""; - val lookupURI: mutable.Map[String,String] = new mutable.HashMap[String,String](); /** this method assign the next character to ch and advances in input */ def nextch: Unit; @@ -75,110 +64,83 @@ abstract class MarkupParser[MarkupType <: AnyRef] { } */ - /** parse attribute and add it to listmap + /** parse attribute and create namespace scope, metadata * [41] Attributes ::= { S Name Eq AttValue } - * AttValue ::= `'` { _ } `'` - * | `"` { _ } `"` - * | `{` scalablock `}` - */ - def xAttributes = { - val aMap = new mutable.HashMap[Pair[String,String],Pair[Int,String]]; + */ + def xAttributes(pscope:NamespaceBinding): Pair[MetaData,NamespaceBinding] = { + var scope: NamespaceBinding = pscope; + var aMap: MetaData = null; while( xml.Parsing.isNameStart( ch )) { val pos = this.pos; - val key1 = xName; - var prefix: String = _; - var key: String = _; - - handle.namespacePrefix(key1) match { - case Some(x @ "xmlns") => - prefix = null; - key = key1.substring(x.length()+1, key1.length()); - case Some(x) => - prefix = x; - key = key1.substring(x.length()+1, key1.length()); + + val qname = xName; + val _ = xEQ; + val value = xAttributeValue(); + + Utility.prefix(qname) match { + case Some("xmlns") => + val prefix = qname.substring(6 /*xmlns:*/ , qname.length()); + scope = new NamespaceBinding(prefix, value, scope); + + case Some(prefix) => + val key = qname.substring(prefix.length()+1, qname.length()); + aMap = new PrefixedAttribute(prefix, key, value, aMap); + case _ => - if( key1 == "xmlns" ) { - prefix= null; - key = ""; - } else { - prefix = ""; - key = key1 - } - } - xEQ; - val delim = ch; - val pos1 = pos; - val value:String = ch match { - case '"' | '\'' => - nextch; - val tmp = xAttributeValue(delim); - nextch; - tmp; - case _ => - reportSyntaxError( "' or \" delimited attribute value expected" ); - "<syntax-error>" - }; - - if(prefix == null) { - handle.internal_namespaceDecl(key, value); - } else { - aMap.update( Pair(prefix,key), Pair(pos,value) ); + if( qname == "xmlns" ) + scope = new NamespaceBinding(null, value, scope); + else + aMap = new UnprefixedAttribute(qname, value, aMap); } if ((ch != '/') && (ch != '>')) xSpace; } - // @todo, iterate over attributes, replace prefix, call handleAttribute. - handle.internal_startPrefixMapping; - val aMap1 = new mutable.HashMap[Pair[String,String],Attribute]; - val it = aMap.elements; - while( it.hasNext ) { - val x @ Pair(Pair(pref,key),Pair(pos,value)) = it.next; - val uri = handle.namespace(pref); - val qkey = Pair(uri, key); - // well-formedness constraint: unique attribute names - if (aMap1.contains(qkey)) - reportSyntaxError( "attribute " + key + " may only be defined once" ); - aMap1.update(qkey, handle.attribute(pos, uri, key, value)); - } - aMap1 + + if(!aMap.wellformed(scope)) + reportSyntaxError( "double attribute"); + + Pair(aMap,scope) } /** attribute value, terminated by either ' or ". value may not contain <. - * @param endch either ' or " + * AttValue ::= `'` { _ } `'` + * | `"` { _ } `"` */ - def xAttributeValue(endch: Char): String = { + def xAttributeValue(): String = { + val endch = ch; + nextch; while (ch != endch) { + if('<' == ch) + reportSyntaxError( "'<' not allowed in attrib value" ); putChar(ch); - nextch + nextch; } + nextch; val str = cbuf.toString(); cbuf.setLength( 0 ); + // @todo: normalize attribute value // well-formedness constraint - if (str.indexOf('<') != -1) { - reportSyntaxError( "'<' not allowed in attrib value" ); "" - } - else - str + str + } /** parse a start or empty tag. * [40] STag ::= '<' Name { S Attribute } [S] * [44] EmptyElemTag ::= '<' Name { S Attribute } [S] */ - protected def xTag: Pair[String, mutable.Map[Pair[String,String],Attribute]] = { - val elemqName = xName; + protected def xTag(pscope:NamespaceBinding): Tuple3[String, MetaData, NamespaceBinding] = { + val qname = xName; xSpaceOpt; - val aMap: mutable.Map[Pair[String,String],Attribute] = - if(xml.Parsing.isNameStart( ch )) { - xAttributes; - } else { - handle.internal_startPrefixMapping; - noAttribs; - }; - Pair(elemqName, aMap); + val Pair(aMap: MetaData, scope: NamespaceBinding) = { + if(xml.Parsing.isNameStart( ch )) + xAttributes(pscope) + else + Pair(null, pscope) + } + Triple(qname, aMap, scope); } /** [42] '<' xmlEndTag ::= '<' '/' Name S? '>' @@ -195,7 +157,7 @@ abstract class MarkupParser[MarkupType <: AnyRef] { * * see [15] */ - def xCharData: Iterable[MarkupType] = { + def xCharData: NodeSeq = { xToken('['); xToken('C'); xToken('D'); @@ -251,7 +213,7 @@ abstract class MarkupParser[MarkupType <: AnyRef] { * * see [15] */ - def xComment: Iterable[MarkupType] = { + def xComment: NodeSeq = { val sb: StringBuffer = new StringBuffer(); xToken('-'); xToken('-'); @@ -267,17 +229,18 @@ abstract class MarkupParser[MarkupType <: AnyRef] { throw FatalError("this cannot happen"); }; - def appendText(pos: Int, ts: mutable.Buffer[MarkupType], txt: String): Unit = { - if (!preserveWS) + /* todo: move this into the NodeBuffer class */ + def appendText(pos: Int, ts: NodeBuffer, txt: String): Unit = { + if (preserveWS) + ts + handle.text(pos, txt); + else for (val t <- TextBuffer.fromString(txt).toText) { - ts.appendAll(handle.text(pos, t.text)); + ts + handle.text(pos, t.text); } - else - ts.appendAll(handle.text(pos, txt)); } - def content: mutable.Buffer[MarkupType] = { - var ts = new mutable.ArrayBuffer[MarkupType]; + def content(pscope: NamespaceBinding): NodeSeq = { + var ts = new NodeBuffer; var exit = false; while( !exit ) { /* if( xEmbeddedBlock ) { @@ -293,23 +256,23 @@ abstract class MarkupParser[MarkupType <: AnyRef] { case '!' => nextch; if ('[' == ch) // CDATA - ts.appendAll(xCharData); + ts + xCharData; else // comment - ts.appendAll(xComment); + ts + xComment; case '?' => // PI nextch; - ts.appendAll(xProcInstr); + ts + xProcInstr; case _ => - ts.appendAll(element1); // child + ts + element1(pscope); // child } - case '{' => + //case '{' => /* if( xCheckEmbeddedBlock ) { ts.appendAll(xEmbeddedExpr); } else {*/ - val str = new StringBuffer("{"); - str.append(xText); - appendText(tmppos, ts, str.toString()); + // val str = new StringBuffer("{"); + // str.append(xText); + // appendText(tmppos, ts, str.toString()); /*}*/ // postcond: xEmbeddedBlock == false! case '&' => // EntityRef or CharRef @@ -319,11 +282,11 @@ abstract class MarkupParser[MarkupType <: AnyRef] { nextch; val theChar = handle.text( tmppos, xCharRef ); xToken(';'); - ts.appendAll( theChar ); + ts + theChar ; case _ => // EntityRef val n = xName ; xToken(';'); - ts.appendAll( handle.entityRef( tmppos, n ) ); + ts + handle.entityRef( tmppos, n ) ; } case _ => // text content appendText(tmppos, ts, xText); @@ -331,48 +294,42 @@ abstract class MarkupParser[MarkupType <: AnyRef] { } /*}*/ } - ts -} /* end content */ + // 2do: optimize seq repr. + new NodeSeq { + val theSeq = ts.toList; + } + } /* end content */ - def element: Iterable[MarkupType] = { + def element(pscope: NamespaceBinding): NodeSeq = { xToken('<'); - element1 + element1(pscope); } /** '<' element ::= xmlTag1 '>' { xmlExpr | '{' simpleExpr '}' } ETag * | xmlTag1 '/' '>' */ - def element1: Iterable[MarkupType] = { - var pref: Map[String, String] = _; - var pos1 = pos; - val Pair(qname, aMap) = xTag; - val ts: mutable.Buffer[MarkupType] = { + def element1(pscope: NamespaceBinding): NodeSeq = { + val pos = this.pos; + val Tuple3(qname, aMap, scope) = xTag(pscope); + val ts = { if(ch == '/') { // empty element xToken('/'); xToken('>'); - //pref = handle.namespaceDecl( aMap ); - //handle.internal_startPrefixMapping( pref ); - noChildren; + NodeSeq.Empty; } else { // element with content xToken('>'); - //pref = handle.namespaceDecl( aMap ); - //handle.internal_startPrefixMapping( pref ); - val tmp = content; + val tmp = content(scope); xEndTag( qname ); tmp; } } - var name = qname; - val uri = handle.namespacePrefix(qname).match { - case Some(pref) => - name = name.substring(pref.length()+1, name.length()); - handle.namespace( pref ); - case _ => - handle.namespace(""); + Utility.prefix(qname) match { + case Some(pre) => + val local = qname.substring(pre.length()+1, qname.length()); + handle.element(pos, pre, local, aMap, scope, ts ); + case _ => + handle.element(pos, null, qname, aMap, scope, ts ); } - val res = handle.element(pos1, uri, name, aMap, ts ); - handle.internal_endPrefixMapping; - res } //def xEmbeddedExpr: MarkupType; @@ -417,7 +374,7 @@ abstract class MarkupParser[MarkupType <: AnyRef] { * * see [15] */ - def xProcInstr: Iterable[MarkupType] = { + def xProcInstr: NodeSeq = { val sb:StringBuffer = new StringBuffer(); val n = xName; if( xml.Parsing.isSpace( ch ) ) { diff --git a/sources/scala/xml/transform/BasicTransformer.scala b/sources/scala/xml/transform/BasicTransformer.scala index bf8f4b24f6..92a715791d 100644 --- a/sources/scala/xml/transform/BasicTransformer.scala +++ b/sources/scala/xml/transform/BasicTransformer.scala @@ -77,7 +77,7 @@ trait BasicTransformer with Function1[Node,Node] { if(ch.eq(nch)) n else - Elem(n.namespace, n.label, n.attributes, nch:_*) + Elem(n.namespace, n.label, n.attributes, n.scope, nch:_*) } } diff --git a/sources/scalac/ast/TreeGen.java b/sources/scalac/ast/TreeGen.java index 9167a4cf94..e6b98f0f42 100644 --- a/sources/scalac/ast/TreeGen.java +++ b/sources/scalac/ast/TreeGen.java @@ -136,6 +136,7 @@ public class TreeGen implements Kinds, Modifiers, TypeTags { /** Builds a string literal. */ public Tree mkStringLit(int pos, String value) { + assert value != null; return Literal(pos, AConstant.STRING(value)); } diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization.check index 497215a742..209f6ec976 100644 --- a/test/files/jvm/serialization.check +++ b/test/files/jvm/serialization.check @@ -74,8 +74,8 @@ x = <html><title>title</title><body></body></html> y = <html><title>title</title><body></body></html> x equals y: true - y equals x: true -x = <html><body><table cellpadding="2" cellspacing="0"><tr><th>Last Name</th><th>First Name</th></tr><tr><td>Tom</td><td>20</td></tr><tr><td>Bob</td><td>22</td></tr><tr><td>James</td><td>19</td></tr></table></body></html> -y = <html><body><table cellpadding="2" cellspacing="0"><tr><th>Last Name</th><th>First Name</th></tr><tr><td>Tom</td><td>20</td></tr><tr><td>Bob</td><td>22</td></tr><tr><td>James</td><td>19</td></tr></table></body></html> +x = <html><body><table cellspacing="0" cellpadding="2"><tr><th>Last Name</th><th>First Name</th></tr><tr><td>Tom</td><td>20</td></tr><tr><td>Bob</td><td>22</td></tr><tr><td>James</td><td>19</td></tr></table></body></html> +y = <html><body><table cellspacing="0" cellpadding="2"><tr><th>Last Name</th><th>First Name</th></tr><tr><td>Tom</td><td>20</td></tr><tr><td>Bob</td><td>22</td></tr><tr><td>James</td><td>19</td></tr></table></body></html> x equals y: true - y equals x: true x = Tim diff --git a/test/files/jvm/xmlLiterals.check b/test/files/jvm/xmlLiterals.check index 4fa9298cd2..95487bee2f 100644 --- a/test/files/jvm/xmlLiterals.check +++ b/test/files/jvm/xmlLiterals.check @@ -67,5 +67,4 @@ Test05Ref <foo>{</foo> <foo> {<bar><baz></baz></bar><bar></bar></foo> namespace -<ns0:foo xmlns:ns0="www.bar.com" xmlns:ns1="www.baz.com"><ns1:baz></ns1:baz></ns0:foo> <bar:foo xmlns:bar="www.bar.com" xmlns="www.baz.com"><baz></baz></bar:foo> diff --git a/test/files/jvm/xmlLiterals.scala b/test/files/jvm/xmlLiterals.scala index 73d6627b1c..e47fa11126 100644 --- a/test/files/jvm/xmlLiterals.scala +++ b/test/files/jvm/xmlLiterals.scala @@ -48,11 +48,13 @@ object Test { val x3 = xx3.toString(); /* ws in element content */ + //Console.println("tmp1:"+x3); + //Console.println("tmp2:"+Elem(null,"mars",e,null).toString() ); assertEquals( noWS( x3 ), - Elem("","hello",e, - Elem("","world",e), - Elem("","test",e), - Elem("","mars",e)).toString() ); + Elem(null,"hello",e,null, + Elem(null,"world",e,null), + Elem(null,"test",e,null), + Elem(null,"mars",e,null)).toString() ); Console.println("ws trimming in patterns"); @@ -72,14 +74,14 @@ object Test { </html>.toString(); assertEquals( noWS( z ), noWS( - Elem("","html",e, - Elem("","body",e, - Elem("","h1",e,Text("Hello World")), - Elem("","p",e,Text("Check the "), - Elem("","a", e,Text("scala")) - % (Attribute("","href","scala.epfl.ch")), + Elem(null,"html",e,null, + Elem(null,"body",e,null, + Elem(null,"h1",e,null,Text("Hello World")), + Elem(null,"p",e,null,Text("Check the "), + Elem(null,"a", e,null,Text("scala")) + % (new UnprefixedAttribute("href","scala.epfl.ch",Null)), Text("page!")) - ) % Attribute("", "background","#FFFFFF") + ) % new UnprefixedAttribute("background","#FFFFFF",Null) ).toString() )); @@ -100,16 +102,16 @@ object Test { /* === embedded Scala blocks === */ def computeDate() = { - Elem("","date", e, Text("now!")); + Elem(null,"date", e, null, Text("now!")); } /* embedding Scala strings as text and elements */ val sc = <hello>{ "World" }{ Text("42") }{ computeDate() }</hello>; assertEquals( sc.child.elements.toList, - List( Text("World"), Text("42"), Elem("", "date", e,Text("now!") ) ) ); + List( Text("World"), Text("42"), Elem(null, "date", e,null, Text("now!") ) ) ); assertEquals( sc.toString(), - Elem("","hello",e,Text("World42"),Elem("","date",e,Text("now!"))).toString() ); + Elem(null,"hello",e,null,Text("World42"),Elem(null,"date",e,null, Text("now!"))).toString() ); def foo( m:Node ):String = m match { case <hello/> => "hello node" @@ -132,11 +134,11 @@ object Test { </tr>; assertEquals( noWS( rows.toList.toString() ), - noWS( List(Elem("","tr",e, - Elem("","td",e,Text("1.1")),Elem("","td",e,Text("1.2")) + noWS( List(Elem(null,"tr",e,null, + Elem(null,"td",e,null,Text("1.1")),Elem(null,"td",e,null, Text("1.2")) ), - Elem("","tr",e, - Elem("","td",e,Text("2.1")),Elem("","td",e,Text("2.2")) + Elem(null,"tr",e,null, + Elem(null,"td",e,null,Text("2.1")),Elem(null,"td",e,null,Text("2.2")) ) ).toString() ) ); @@ -144,9 +146,9 @@ object Test { val rows3 = <tr> a <!-- an XML comment --> b <?pinotext?> c <?pi text?> d </tr>; // these are not equal as comments are valid XML Info items. - assertEquals( rows2, Elem("","tr",e,Comment(" an XML comment "),ProcInstr("pinotext",""),ProcInstr("pi","text"))); + assertEquals( rows2, Elem(null,"tr",e,null,Comment(" an XML comment "),ProcInstr("pinotext",""),ProcInstr("pi","text"))); - assertEquals( rows3, Elem("","tr",e,Text("a"),Comment(" an XML comment "),Text("b"),ProcInstr("pinotext",""),Text("c"),ProcInstr("pi","text"),Text("d"))); + assertEquals( rows3, Elem(null,"tr",e,null,Text("a"),Comment(" an XML comment "),Text("b"),ProcInstr("pinotext",""),Text("c"),ProcInstr("pi","text"),Text("d"))); } @@ -198,8 +200,8 @@ object Test03Servlet { case <table>{ xs @ _* }</table> => <table align="center">{ beautify( xs )}</table> - case Elem("", label, _, xs @ _* ) => - new Elem("", label, beautify( xs ):_*) + case Elem(null, label, _, _, xs @ _* ) => + new Elem(null, label, e, null, beautify( xs ):_*) case _ => n } @@ -228,8 +230,7 @@ object Test03Servlet { */ def doGetXML() = { beautify( page( List( format( getMessage( "message" ) )) )); - /* page( List( format( theMessage ))); */ - + //page( List( format( theMessage ))); } def main( args:Array[String] ) = { @@ -253,14 +254,14 @@ object Test03Servlet { Console.println( onlyOne ); val tryBrace = <try>Now escaped {{ braces } </try>; - assertEquals( tryBrace, Elem("","try",e,Text("Now escaped { braces }"))); + assertEquals( tryBrace, Elem(null,"try",e,null,Text("Now escaped { braces }"))); val tryBrace2 = <try myAttrib={(3+4).toString() }> cool ?</try>; assertEquals( tryBrace2.attribute("myAttrib"), "7" ); /* Scala comments are not allowed in XML literals. see neg(2) */ val zzz = <hello>/* no comment */</hello>; - assertEquals( zzz, Elem("","hello", e, Text("/* no comment */"))); + assertEquals( zzz, Elem(null,"hello", e,null, Text("/* no comment */"))); } @@ -280,10 +281,6 @@ object Test03Servlet { </bar:foo>; Console.println( foo ); - val h = new scala.collection.mutable.HashMap[String,String](); - h("www.bar.com") = "bar"; - h("www.baz.com") = ""; - Console.println( Utility.toXML(foo, h) ); } diff --git a/test/files/jvm/xmlstuff.check b/test/files/jvm/xmlstuff.check index 397a8970d6..393a4813c8 100644 --- a/test/files/jvm/xmlstuff.check +++ b/test/files/jvm/xmlstuff.check @@ -1,23 +1,3 @@ -passed ok -equality -passed ok -passed ok -passed ok -passed ok -passed ok -xpath \ -passed ok -passed ok -passed ok -passed ok -passed ok -passed ok -passed ok -passed ok -xpath \\ DESCENDANTS -passed ok -passed ok -passed ok NodeSeq passed ok <result> @@ -46,4 +26,3 @@ namespaces passed ok passed ok passed ok -passed ok diff --git a/test/files/jvm/xmlstuff.scala b/test/files/jvm/xmlstuff.scala index e68f692bdb..1418707f95 100644 --- a/test/files/jvm/xmlstuff.scala +++ b/test/files/jvm/xmlstuff.scala @@ -6,181 +6,8 @@ import scala.xml.{Node,NodeSeq,Elem,Text}; object Test with Application { - val e = Node.NoAttributes; - -/* - def eq( a:Seq[Node], b:Seq[Node] ):boolean = { - (a.length == b.length) && eq(a.elements,b.elements) - } - def eq( ita:Iterator[Node], itb:Iterator[Node] ) = { - var res = true; - while( ita.hasNext && itb.hasNext && res ) { - res = (ita.next == itb.next); - }; - !ita.hasNext && !itb.hasNext && res - } - */ - val xmlFile1 = "<hello><world/></hello>"; - val isrc1 = new InputSource( new StringReader( xmlFile1 ) ); - val parsedxml1 = XML.load( isrc1 ); - val isrc11 = new InputSource( new StringReader( xmlFile1 ) ); - val parsedxml11 = XML.load( isrc11 ); - - val c = new Node { - def label = "hello"; - def namespace = ""; - def child = List(Elem("","world",e)); - def attributes = e; - }; - - assertSameElements( List( 3 ), List( 3 )); - - Console.println("equality"); - assertEquals( c, parsedxml11 ); - assertEquals( parsedxml1, parsedxml11 ); - assertSameElements( List(parsedxml1), List(parsedxml11)); - assertSameElements( Iterator.fromArray(Predef.Array(parsedxml1)).toList, List(parsedxml11)); - - val x2 = "<book><author>Peter Buneman</author><author>Dan Suciu</author><title>Data on ze web</title></book>"; - - val i = new InputSource( new StringReader( x2 )); - val x2p = XML.load( i ); - - assertEquals(x2p, Elem("","book",e, - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","title",e,Text("Data on ze web")))); - - val xmlFile2 = "<bib><book><author>Peter Buneman</author><author>Dan Suciu</author><title>Data on ze web</title></book><book><author>John Mitchell</author><title>Foundations of Programming Languages</title></book></bib>"; - val isrc2 = new InputSource( new StringReader( xmlFile2 ) ); - val parsedxml2 = XML.load( isrc2 ); - - // xmlFile2/book -> book,book - Console.println("xpath \\"); - - - assertSameElements( parsedxml1 \ "_" , List( Elem("","world",e) ) ); - - assertSameElements( parsedxml1 \ "world", List( Elem("","world",e) ) ); - -/* - Console.println( parsedxml2 \ "_" ); - Console.println( (parsedxml2 \ "_" ).elements); - for( val i <- (parsedxml2 \ "_" ).elements) { - Console.println( i ); - }; - */ - assertSameElements( - parsedxml2 \ "_" , - - List( - Elem("","book", e, - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","title",e,Text("Data on ze web"))), - Elem("","book",e, - Elem("","author",e,Text("John Mitchell")), - Elem("","title",e,Text("Foundations of Programming Languages")))) - ); - assertEquals( (parsedxml2 \ "author").length, 0 ); - - assertSameElements( - parsedxml2 \ "book", - - List( - Elem("","book",e, - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","title",e,Text("Data on ze web"))), - Elem("","book",e, - Elem("","author",e,Text("John Mitchell")), - Elem("","title",e,Text("Foundations of Programming Languages"))) - ) - ); - - assertSameElements( - - parsedxml2 \ "_" \ "_", - - List( - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","title",e,Text("Data on ze web")), - Elem("","author",e,Text("John Mitchell")), - Elem("","title",e,Text("Foundations of Programming Languages")) - ) - ); - - assertSameElements( - - parsedxml2 \ "_" \ "author", - - List( - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","author",e,Text("John Mitchell")) - ) - - ); - - assertSameElements( (parsedxml2 \ "_" \ "_" \ "author"), List() ); - - Console.println("xpath \\\\ DESCENDANTS"); - - assertSameElements( - - parsedxml2 \\ "author", - - List( - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","author",e,Text("John Mitchell")) - ) - - ); - - assertEquals( - - (new NodeSeq { val theSeq = List( parsedxml2 ) }) \\ "_", - - List( - Elem("","bib",e, - Elem("","book",e, - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","title",e,Text("Data on ze web"))), - Elem("","book",e, - Elem("","author",e,Text("John Mitchell")), - Elem("","title",e,Text("Foundations of Programming Languages")))), - Elem("","book",e, - Elem("","author",e,Text("Peter Buneman")), - Elem("","author",e,Text("Dan Suciu")), - Elem("","title",e,Text("Data on ze web"))), - Elem("","author",e,Text("Peter Buneman")), - Text("Peter Buneman"), - Elem("","author",e,Text("Dan Suciu")), - Text("Dan Suciu"), - Elem("","title",e,Text("Data on ze web")), - Text("Data on ze web"), - Elem("","book",e, - Elem("","author",e,Text("John Mitchell")), - Elem("","title",e,Text("Foundations of Programming Languages"))), - Elem("","author",e,Text("John Mitchell")), - Text("John Mitchell"), - Elem("","title",e,Text("Foundations of Programming Languages")), - Text("Foundations of Programming Languages") - ) - ); - - - assertSameElements( - - parsedxml2 \\ "title", - - List( - Elem("","title",e,Text("Data on ze web")), - Elem("","title",e,Text("Foundations of Programming Languages"))) - ); + //val e: scala.xml.MetaData = null; //Node.NoAttributes; + //val sc: scala.xml.NamespaceBinding = null; Console.println("NodeSeq"); @@ -221,7 +48,7 @@ object Test with Application { </entry> </reviews>; - Console.println( new scala.xml.PrettyPrinter(80, 5).format ( + Console.println( new scala.xml.PrettyPrinter(80, 5).formatNodes ( for( val t <- books \\ "title"; val r <- reviews \\ "entry"; r \ "title" == t) yield @@ -236,7 +63,6 @@ object Test with Application { for( val t @ <book><title>Blabla</title></book> <- new NodeSeq { val theSeq = books.child }.asList) yield t ); - val phoneBook = <phonebook> <descr> @@ -264,7 +90,7 @@ val addrBook = </entry> </addrbook>; - Console.println( new scala.xml.PrettyPrinter(80, 5).format ( + Console.println( new scala.xml.PrettyPrinter(80, 5).formatNodes ( for( val t <- addrBook \\ "entry"; val r <- phoneBook \\ "entry"; t \ "name" == r \ "name") yield @@ -298,6 +124,7 @@ val addrBook = true); /* namespaces */ + // begin tmp Console.println("namespaces"); val cuckoo = <cuckoo xmlns="http://cuckoo.com"> <foo/> @@ -307,7 +134,11 @@ val addrBook = for( val n <- cuckoo.child ) { assertEquals( n.namespace, "http://cuckoo.com"); } + // end tmp + /* +DEPRECATED, don't support namespaces in pattern match anymore +*/ /* assertEquals( true, cuckoo match { case <cuckoo xmlns="http://cuckoo.com"> @@ -316,11 +147,14 @@ val addrBook = </cuckoo> => true; case _ => false; }); */ + /* + // begin tmp assertEquals( false, cuckoo match { case <cuckoo> <foo/> <bar/> </cuckoo> => true; case _ => false; }); - + // end tmp + */ } |