AsFix->BGF part complete

git-svn-id: https://slps.svn.sourceforge.net/svnroot/slps@184 ab42f6e0-554d-0410-b580-99e487e6eeb2

topics/extraction/asfix2btf/AsFixToBGF.asf

@@ -0,0 +1,133 @@
+equations
+
+[map-asfix-to-bgf]
+asfix2bgf(&T1)
+=
+<bgf:grammar>
+	trafoProds(accuProds(&T1,))
+</bgf:grammar>
+
+        [traversal] accuProds(appl(&P1,[&Tcs1]),&P*2) = accuProds(&Tcs1,&P*2 &P1)
+[default-traversal] accuProds(&T1,&Tcs1,&P*2) = accuProds(&T1,accuProds(&Tcs1,&P*2))
+
+[recursion]       trafoProds(&P1 &P*2) = trafoProd(&P1)trafoProds(&P*2)
+[recursion-final] trafoProds() = 
+
+[prod-to-null] trafoProd(prod([],&S0,&As1)) =
+[prod-to-null] trafoProd(list(&S1)) =
+[prod-to-null] trafoProd(prod([&Scs1],lex(&S1),&As1)) = 
+[prod-to-null] trafoProd(prod([&Scs1],lit(&Z1),&As1)) = 
+
+[kill-layout-before] trafoProd(prod([cf(opt(layout)),&Scs1],&S0,&As1)) = trafoProd(prod([&Scs1],&S0,&As1))
+[kill-layout-before] trafoProd(prod([cf(layout),&Scs1],&S0,&As1)) = trafoProd(prod([&Scs1],&S0,&As1))
+[kill-layout-before] trafoProd(prod([lex(&S1),&Scs1],&S0,&As1)) = trafoProd(prod([&Scs1],&S0,&As1))
+[kill-layout-before] trafoProd(prod([cf(layout),&Scs1],&S0,&As1)) = trafoProd(prod([&Scs1],&S0,&As1))
+
+[prod-start] trafoProd(prod([cf(sort(&Z1)),&Scs1],sort("<START>"),&As1)) = <root>strcon2chardata(&Z1)</root>
+
+[a]
+trafoProd(prod(&Ss1,cf(sort(&Z0)),&As1))
+=
+<bgf:production>
+	derivelabel(&As1)
+	<nonterminal>strcon2chardata(&Z0)</nonterminal>
+	symbols2expr(&Ss1)
+</bgf:production>
+
+[lit-prod-labelled]
+trafoProd(prod([lit(&Z1)],cf(sort(&Z0)),&As1))
+=
+<bgf:production>
+	derivelabel(&As1)
+	<nonterminal>strcon2chardata(&Z0)</nonterminal>
+	<bgf:expression>
+		<terminal>strcon2chardata(&Z1)</terminal>
+	</bgf:expression>
+</bgf:production>
+
+[map-cf]
+symbols2expr([cf(&S1)])
+=
+symbols2expr([&S1])
+
+[map-plus]
+symbols2expr([iter(&S1)])
+=
+<bgf:expression>
+	<plus>
+		symbols2expr([&S1])
+          </plus>
+</bgf:expression>
+
+[map-optional]
+symbols2expr([opt(&S1)])
+=
+<bgf:expression>
+	<optional>symbols2expr([&S1])</optional>
+</bgf:expression>
+
+[map-literal-to-terminal]
+symbols2expr([lit(&Z1)])
+=
+<bgf:expression>
+	<terminal>strcon2chardata(&Z1)</terminal>
+</bgf:expression>
+
+[map-sort-to-nonterminal]
+symbols2expr([sort(&Z1)])
+=
+<bgf:expression>
+	<nonterminal>strcon2chardata(&Z1)</nonterminal>
+</bgf:expression>
+
+[map-layout-to-nothing]
+symbols2expr([cf(opt(layout)),&Scs2])
+=
+symbols2expr([&Scs2])
+
+[default-map-one]
+symbols2expr([&S1])
+=
+<bgf:expression>
+	<unknown>
+		?
+	</unknown>
+</bgf:expression>
+
+[default-map]
+symbols2expr([&S1,&Scs2])
+=
+<bgf:expression>
+	<sequence>
+		flattenexprs([&S1,&Scs2])
+	</sequence>
+</bgf:expression>
+
+[map-flattened-no-layout]
+flattenexprs([cf(opt(layout)),&Scs2])
+=
+flattenexprs([&Scs2])
+
+[default-map-flattened]
+flattenexprs([&S1,&Scs2])
+=
+symbols2expr([&S1])flattenexprs([&Scs2])
+
+[map-flattened-final]
+flattenexprs([])
+=
+
+[labeling-no-label]
+derivelabel(no-attrs) = 
+
+[labeling-only-label]
+derivelabel(attrs([term(cons(&L1))])) = <label>idcon2chardata(&L1)</label>
+
+[labeling-first-label]
+derivelabel(attrs([term(cons(&L1)),&A*2])) = <label>idcon2chardata(&L1)</label>
+
+[default-labeling-not-first-label]
+derivelabel(attrs([&A1,&A*2])) = derivelabel(attrs([&A*2]))
+
+[default-labeling-last-label]
+derivelabel(attrs([&A1])) = 

topics/extraction/asfix2btf/AsFixToBGF.sdf

@@ -0,0 +1,47 @@
+module AsFixToBGF
+
+imports 
+	languages/asfix/syntax/Parsetree
+	languages/xml/syntax/XML
+	basic/NatCon
+	AsFixTokens
+	Tokens
+
+exports
+	sorts
+		Element Tree
+	context-free syntax
+		asfix2bgf(Tree) -> Element
+
+hiddens
+context-free syntax
+	accuProds({Tree ","}+,Production*) -> Production* {traversal(accu,top-down,break)}
+	trafoProds(Production*) -> Content*
+	trafoProd(Production) -> Content*
+	symbols2expr(Symbols) -> Element
+	flattenexprs(Symbols) -> Content*
+	derivelabel(Attributes) -> Content*
+
+variables
+	"&A" [0-9]+ -> Attr
+	"&A*" [0-9]+ -> {Attr ","}+
+	"&As" [0-9]+ -> Attributes
+	"&C" [0-9]+ -> Content
+	"&C*" [0-9]+ -> Content*
+	"&E" [0-9]+ -> Element
+	"&N" [0-9]+ -> Sort
+	"&T" [0-9]+ -> Tree
+	"&T*" [0-9]+ -> Tree*
+	"&Tcs" [0-9]+ -> {Tree ","}+
+	"&S" [0-9]+ -> Symbol
+	"&S*" [0-9]+ -> Symbol*
+	"&Ss" [0-9]+ -> Symbols
+	"&Scs" [0-9]+ -> {Symbol ","}*
+	"&Z" [0-9]+ -> StrCon
+	"&P" [0-9]+ -> Production
+	"&P*" [0-9]+ -> Production*
+	"&Ps" [0-9]+ -> Productions
+	"&I" [0-9]+ -> NatCon
+	"&Ics" [0-9]+ -> {NatCon ","}+
+	"&B" [0-9]+ -> Args
+	"&L" [0-9]+ -> IdCon

topics/extraction/asfix2btf/AsFixTokens.asf

@@ -11,48 +11,6 @@ chardata(&Char1 &Char*1) := tree2chardata([&T*2])
 ==============================================
 tree2chardata([&N1,&T*2]) = chardata ( &Chr1 &Char1 &Char*1 )
 
-
-
-
-[zero]
-strchar(&Chr1) := mapsymbol(&N1)
-========================================
-list2chardata([&N1]) = chardata(&Chr1)
-
-[one]
-strchar(&Chr1) := mapsymbol(&N1),
-chardata(&Char1 &Char*1) := list2chardata([&N*2])
-==============================================
-list2chardata([&N1,&N*2]) = chardata ( &Chr1 &Char1 &Char*1 )
-
-[one]
-symbols2chardata([&N1]) = [mapsymbol(&N1)]
-
-[one]
-&C1 := mapsymbol(&N1),
-[&C*2] := symbols2chardata([&N*2])
-===============================================
-symbols2chardata([&N1,&N*2]) = [&C1,&C*2]
-
-[strcon-of-length-1]
-array2chardata([&StrChr1]) = strcon(\" &StrChr1 \")
-
-[strcon-of-length-1]
-strcon(\" &StrChr+1 \" ):= array2chardata([&C*2])
-====================================================
-array2chardata([&StrChr1,&C*2]) = strcon(\" &StrChr1 &StrChr+1 \")
-
-[strcon-of-length-1]
-strchar(&Chr1) := &StrChr1
-========================================
-array2chars([&StrChr1]) = chardata(&Chr1)
-
-[strcon-of-length-1]
-strchar(&Chr1) := &StrChr1,
-chardata(&Char1 &Char*1) := array2chars([&C*2])
-====================================================
-array2chars([&StrChr1,&C*2]) = chardata ( &Chr1 &Char1 &Char*1 )
-
 [alpha-a] mapsymbol(97) = a
 [alpha-b] mapsymbol(98) = b
 [alpha-c] mapsymbol(99) = c

topics/extraction/asfix2btf/AsFixTokens.sdf

@@ -1,7 +1,5 @@
 module AsFixTokens
 
-%% mapTree(appl(prod([lex(iter(char-class([range(97,122)])))],lex(sort("NAME")),no-attrs),[appl(list(lex(iter(char-class([range(97,122)])))),[102,117,110])]))
-%% [97,122] -> a,z
 %% [102,117,110] -> fun
 
 imports 
@@ -13,38 +11,23 @@ imports
 exports
 
 	sorts
-		CharNumList CharValList StrCon CharData
-	context-free start-symbols
-		CharNumList CharValList
+		Args CharData
 	context-free syntax
-	"[" {NatCon ","}+ "]" -> CharNumList
-	"[" {StrChar ","}+ "]" -> CharValList
-	"symbols2chardata" "(" CharNumList ")" -> CharValList
-	"mapsymbol" "(" NatCon ")" -> StrChar
-	array2chardata(CharValList) -> StrCon
-	array2chars(CharValList) -> CharData
-	list2chardata(CharNumList) -> CharData
-	tree2chardata(Args) -> CharData
+		tree2chardata(Args) -> CharData
 
 hiddens
-%%	imports
-		%%basic/Whitespace
+	context-free syntax
+		mapsymbol(NatCon) -> StrChar
 	variables
-		"&N" [0-9]+ -> NatCon		%% char number
-		"&N*" [0-9]+ -> {NatCon ","}+	%% char number
-		"&C" [0-9]+ -> StrChar
-		"&C*" [0-9]+ -> {StrChar ","}+
-		"&T" [0-9]+ -> Tree
+		"&N" [0-9]+ -> NatCon
 		"&T*" [0-9]+ -> {Tree ","}+
 	lexical variables
-		"&StrChr" [0-9]+ -> StrChar
-		"&StrChr+" [0-9]+ -> StrChar+
 		"&Chr" [0-9]* -> ~[\0-\31\n\t\"\\\<\&]
 		"&Char" [0-9]* -> ~[\<\&]
 		"&Char*" [0-9]* -> ~[\<\&]*
 
-		%% "&S" [0-9]+ -> Symbol
-
 %% Python code to generate the boring part of the ASF:
 %% for x in range(97,123):
-%%  print '['+chr(x)+']','mapsymbol('+`x`+')','=',chr(x)
+%%  print '[alpha-'+chr(x)+']','mapsymbol('+`x`+')','=',chr(x)
+%% for x in range(48,58):
+%%  print '[digit-'+chr(x)+']','mapsymbol('+`x`+')','=',chr(x)

topics/extraction/asfix2btf/Main.asf

@@ -1,9 +1,12 @@
 equations
 
-[map-asfix-to-btf]  
+[map-asfix-to-btf]
 main(parsetree(&T1,&I1))
 =
-mapTree(&T1)
+<btf:root xmlns:btf="http://planet-sl.org/btf" xmlns:bgf="http://planet-sl.org/bgf">
+	asfix2bgf(&T1)
+	mapTree(&T1)
+</btf:root>
 
 [kill-layout-before]
 mapTree(appl(prod([cf(opt(layout)),&Scs1],&S0,&As1),[&T1,&Tcs1]))

topics/extraction/asfix2btf/Main.sdf

@@ -4,6 +4,7 @@ module Main
 	languages/asfix/syntax/Parsetree
 	languages/xml/syntax/XML
 	basic/NatCon
+	AsFixToBGF
 	AsFixTokens
 	Tokens
 
@@ -20,11 +21,6 @@ module Main
   hiddens
 
     context-free syntax
-	accuTrees(ParseTree,Tree*) -> Tree* {traversal(accu,top-down,break)}
-	accuTrees(Args,Tree*) -> Tree* {traversal(accu,top-down,break)}
-	accuTrees(Tree*,Tree*) -> Tree* {traversal(accu,top-down,break)}
-	trafoTrees(Tree*) -> Content*
-	trafoTree(Tree) -> Element
 	"mapTrees" "(" {Tree ","}* ")" -> Content*
 	"mapTree" "(" Tree ")" -> Element
 %%	"mapTree2Tree" "(" Tree ")" -> Element
@@ -62,3 +58,4 @@ module Main
 	"&Ps" [0-9]+ -> Productions
 	"&I" [0-9]+ -> NatCon
 	"&Ics" [0-9]+ -> {NatCon ","}+
+	"&B" [0-9]+ -> Args

topics/extraction/asfix2btf/Makefile

@@ -1,19 +1,13 @@
-validator = ../../../download/msv/msv.jar
 metaenv = `which asfe | xargs dirname`/..
 sdfl = ${metaenv}/share/sdf-library/library
 asfl = ${metaenv}/share/asf-library/library
-schemata = ../../../shared/xsd
 
 all: build test
 
 build: Main.tbl Main.eqs
 
 Main.eqs: *.sdf *.asf
-	eqs-dump -m Main -o 1.eqs
-	eqs-dump -m Tokens -o 2.eqs
-	eqs-dump -m AsFixTokens -o 3.eqs
-	concat-asf -o Main.eqs 1.eqs 2.eqs 3.eqs
-	rm -f ?.eqs
+	eqs-dump -m Main -o Main.eqs
 
 Main.tbl: *.sdf
 	cp ../sdf2bgf/Tokens.* .
@@ -37,7 +31,7 @@ tblcat:
 	@cat ${sdfl}/basic/StrCon.sdf >> Main.def
 	@cat ${sdfl}/basic/IdentifierCon.sdf >> Main.def
 	@cat ${sdfl}/basic/Comments.sdf >> Main.def
-	@cat Main.sdf Tokens.sdf >> Main.def
+	@cat Main.sdf Tokens.sdf AsFixTokens AsFixToBGF>> Main.def
 	sdf2table -m Main Main.def
 
 test:
@@ -47,10 +41,10 @@ test:
 	@echo "main(" > fac.trm
 	@cat ../../fl/shared/factorial.txt | python ../../fl/asfsdf/pre.py | sglr -p ../../fl/asfsdf/FL.tbl -t >> fac.trm
 	@echo ")" >> fac.trm
-	cat asfix.trm | sglr -p Main.tbl | asfe -e Main.eqs | unparsePT | python post.py > small.btf
-	cat fac.trm | sglr -p Main.tbl | asfe -e Main.eqs | unparsePT | python post.py > myfactorial.btf
+	cat asfix.trm | sglr -p Main.tbl | asfe -e Main.eqs | unparsePT > small.btf
+	cat fac.trm | sglr -p Main.tbl | asfe -e Main.eqs | unparsePT > myfactorial.btf
 	cp ../xml2btf/tests/factorial.btf .
-	java -jar ${validator} -warning ${schemata}/btf.xsd *.btf
+	ls -1 *.btf | xargs -n1 checkxml btf
 
 clean:
 	rm -f reduct.out