Navigation

← Previous Changeset
Next Changeset →

Changeset 2183

Timestamp:

07/04/08 04:19:22 (3 months ago)

Author:

jdn

Message:

[Syntax] changed so much I forgot why...

Files:

trunk/ProjectFortress/astgen/Fortress.ast (modified) (1 diff)
trunk/ProjectFortress/build.xml (modified) (1 diff)
trunk/ProjectFortress/src/com/sun/fortress/astgen/TemplateGapClass.java (added)
trunk/ProjectFortress/src/com/sun/fortress/astgen/TemplateGapNodeCreator.java (added)
trunk/ProjectFortress/src/com/sun/fortress/astgen/TemplateVisitorGenerator.java (modified) (3 diffs)
trunk/ProjectFortress/src/com/sun/fortress/nodes_util/NodeUtil.java (modified) (1 diff)
trunk/ProjectFortress/src/com/sun/fortress/parser/Keyword.rats (modified) (1 diff)
trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/SyntaxAbstractionJUTestAll.java (modified) (1 diff)
trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/phases/TemplateChecker.java (modified) (10 diffs)
trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/phases/TemplateParser.java (modified) (1 diff)
trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/util/SyntaxAbstractionUtil.java (modified) (1 diff)
trunk/ProjectFortress/static_tests/syntax_abstraction/SXXTemplateParamsAreNotApplicable.fsi (modified) (1 diff)
trunk/ProjectFortress/static_tests/syntax_abstraction/SyntaxRepetition.fsi (modified) (2 diffs)
trunk/ProjectFortress/static_tests/syntax_abstraction/SyntaxRepetitionUse.fss (modified) (1 diff)
trunk/ProjectFortress/third_party/astgen/astgen.jar (modified) (previous)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/ProjectFortress/astgen/Fortress.ast

r2181	r2183
35	35	customGenerator com.sun.fortress.astgen.FortressAstGenerator;
36	36	customGenerator com.sun.fortress.astgen.TemplateVisitorGenerator;
	37	// customPreprocessor com.sun.fortress.astgen.TemplateGapNodeCreator;
37	38
38	39	package com.sun.fortress.nodes;

trunk/ProjectFortress/build.xml

r2147	r2183
347	347	<uptodate srcfile="${astgen.src}/Fortress.ast"
348	348	targetfile="${library}/FortressAst.fss" />
349		<uptodate srcfile="${basedir}/src/com/sun/fortress/astgen/FortressAstGenerator.java"
350		targetfile="${library}/FortressAst.fsi" />
	349	<uptodate targetfile="${astgen}/Fortress.ast">
	350	<srcfiles dir="${preparser}" includes="${basedir}/src/com/sun/fortress/astgen/*.java"/>
	351	</uptodate>
351	352	</and>
352	353	</condition>

trunk/ProjectFortress/src/com/sun/fortress/astgen/TemplateVisitorGenerator.java

r2083	r2183
18	18	package com.sun.fortress.astgen;
19	19
	20
20	21	import java.util.LinkedList;
21	22	import java.util.List;
…	…
24	25	import edu.rice.cs.astgen.NodeClass;
25	26	import edu.rice.cs.astgen.Field;
	27	import edu.rice.cs.astgen.NodeInterface;
26	28	import edu.rice.cs.astgen.NodeType;
27	29	import edu.rice.cs.astgen.TabPrintWriter;
28	30	import edu.rice.cs.astgen.UpdateVisitorGenerator;
	31	import edu.rice.cs.astgen.Types.TypeName;
	32	import edu.rice.cs.plt.iter.IterUtil;
29	33	import edu.rice.cs.plt.tuple.Option;
	34	import edu.rice.cs.plt.tuple.Pair;
30	35
31	36	public class TemplateVisitorGenerator extends UpdateVisitorGenerator {
…	…
57	62	writer.startLine(" */");
58	63	writer.startLine("public abstract class " + visitorName);
59
	64
60	65	writer.print(" extends " + extendedVisitorName);
61
	66
62	67	writer.print(" {");
63	68	writer.indent();
64	69	writer.println();
65
	70
66	71	writer.startLine("/** Methods to recur on each child. */");
67	72	for (NodeType t : ast.descendents(root)) {
68		if (!t.isAbstract()) {
69		writer.println();
70		outputVisitMethod(t, writer, root);
71		}
	73	if (!t.isAbstract()) {
	74	writer.println();
	75	outputVisitMethod(t, writer, root);
	76	}
72	77	}
73
74		outputHandleTemplateMethod(writer);
75
	78
	79	NodeType templateGapInterface = null;
	80	for (NodeInterface ni: ast.interfaces()) {
	81	if (ni.name().equals("TemplateGap")) {
	82	templateGapInterface = ni;
	83	}
	84	}
	85	outputForCaseOnly(templateGapInterface, writer, root);
	86
76	87	writer.unindent();
77	88	writer.startLine("}");
78	89	writer.println();
79	90	writer.close();
80		}
81
	91	}
	92
82	93	@Override
83	94	protected void outputVisitMethod(NodeType t, TabPrintWriter writer, NodeType root) {
84	95	outputForCaseHeader(t, writer, root.name(), "");
85	96	writer.indent();
86		writer.startLine("if (that instanceof TemplateGap) {");
87		writer.indent();
88		writer.startLine("handleTemplateGap((TemplateGap) that);");
89		writer.unindent();
90		writer.startLine("}");
91		List<String> recurVals = new LinkedList<String>();
92		for (Field f : t.allFields(ast)) {
93		Option<String> recur = recurExpression(f.type(), "that." + f.getGetterName() + "()", root, true);
94		if (recur.isSome()) {
95		String recurName = f.name() + "_result";
96		writer.startLine(f.type().name() + " " + recurName + " = " + recur.unwrap() + ";");
97		recurVals.add(recurName);
98		}
	97
	98	boolean isTemplateGap = false;
	99	for (TypeName typeName: t.interfaces()) {
	100	if (typeName.name().equals("TemplateGap")) {
	101	isTemplateGap = true;
	102	}
99	103	}
100		writer.startLine("return " + visitorMethodName(t) + "Only(that");
101		for (String recurVal : recurVals) { writer.print(", " + recurVal); }
102		writer.print(");");
	104
	105	if (isTemplateGap) {
	106	List<String> recurVals = new LinkedList<String>();
	107	for (Field f : t.fields()) {
	108	Option<String> recur = recurExpression(f.type(), "that." + f.getGetterName() + "()", root, true);
	109	if (recur.isSome()) {
	110	String recurName = f.name() + "_result";
	111	writer.startLine(f.type().name() + " " + recurName + " = " + recur.unwrap() + ";");
	112	recurVals.add(recurName);
	113	}
	114	}
	115	writer.startLine("return forTemplateGapOnly((TemplateGap) that");
	116	for (String recurVal : recurVals) { writer.print(", " + recurVal); }
	117	writer.print(");");
	118	}
	119	else {
	120	List<String> recurVals = new LinkedList<String>();
	121	for (Field f : t.allFields(ast)) {
	122	Option<String> recur = recurExpression(f.type(), "that." + f.getGetterName() + "()", root, true);
	123	if (recur.isSome()) {
	124	String recurName = f.name() + "_result";
	125	writer.startLine(f.type().name() + " " + recurName + " = " + recur.unwrap() + ";");
	126	recurVals.add(recurName);
	127	}
	128	}
	129	writer.startLine("return " + visitorMethodName(t) + "Only(that");
	130	for (String recurVal : recurVals) { writer.print(", " + recurVal); }
	131	writer.print(");");
	132	}
103	133	writer.unindent();
104	134	writer.startLine("}");
105	135	writer.println();
	136	}
	137
	138	protected void outputForCaseOnly(NodeType t, TabPrintWriter writer, NodeType root) {
	139	// only called for concrete cases; must not delegate
	140	List<String> params = new LinkedList<String>(); // "type name" strings
	141	List<String> getters = new LinkedList<String>(); // expressions
	142	List<String> paramRefs = new LinkedList<String>(); // variable names or null
	143	for (Field f : t.allFields(ast)) {
	144	getters.add("that." + f.getGetterName() + "()");
	145	if (canRecurOn(f.type(), root)) {
	146	String paramName = f.name() + "_result";
	147	params.add(f.type().name() + " " + paramName);
	148	paramRefs.add(paramName);
	149	}
	150	else { paramRefs.add(null); }
	151	}
	152	outputForCaseHeader(t, writer, root.name(), "Only", params);
	153	writer.indent();
	154	if (params.isEmpty()) { writer.startLine("return that;"); }
	155	else {
	156	writer.startLine("if (");
	157	boolean first = true;
	158	for (Pair<String, String> getterAndRef : IterUtil.zip(getters, paramRefs)) {
	159	if (getterAndRef.second() != null) {
	160	if (first) { first = false; }
	161	else { writer.print(" && "); }
	162	writer.print(getterAndRef.first() + " == " + getterAndRef.second());
	163	}
	164	}
	165	writer.print(") return that;");
	166
	167	writer.startLine("else return that;"); // new " + t.name() + "(");
	168	// first = true;
	169	// for (Pair<String, String> getterAndRef : IterUtil.zip(getters, paramRefs)) {
	170	// if (first) { first = false; }
	171	// else { writer.print(", "); }
	172	// if (getterAndRef.second() == null) { writer.print(getterAndRef.first()); }
	173	// else { writer.print(getterAndRef.second()); }
	174	// }
	175	// writer.print(");");
	176	}
	177	writer.unindent();
	178	writer.startLine("}");
106	179	}
107
108		private void outputHandleTemplateMethod(TabPrintWriter writer) {
109		writer.startLine("public void handleTemplateGap(TemplateGap that) {");
110		writer.indent();
111		writer.startLine("return;");
112		writer.unindent();
113		writer.startLine("}");
114		}
	180
115	181	}

trunk/ProjectFortress/src/com/sun/fortress/nodes_util/NodeUtil.java

r1962	r2183
329	329	return new IterableOnceForLValueList(d.getLhs());
330	330	}
	331	public IterableOnce<String> forGrammarDecl(GrammarDecl d) {
	332	return new UnitIterable<String>(d.getName().getText());
	333	}
331	334	});
332	335	}

trunk/ProjectFortress/src/com/sun/fortress/parser/Keyword.rats

r2045	r2183
50	50	"tryatomic", "type", "typecase", "unit",
51	51	"value", "var", "where", "while",
52		"widens", "with", "wrapped"~~, "gap"~~
	52	"widens", "with", "wrapped"
53	53	});
54	54	}

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/SyntaxAbstractionJUTestAll.java

r2165	r2183
42	42	"SyntaxRepetitionUse.fss",
43	43	"ImportApiEmptyApiWhichImportsNonEmptyApiUse.fss",
44		"UsingJavaIdentifiersAsPatternVariablesUse.fss");
	44	"UsingJavaIdentifiersAsPatternVariablesUse.fss",
	45	"UsingJavaIdentifiersAsPatternVariables.fss");
45	46
46	47	// "SyntaxTest.fss",

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/phases/TemplateChecker.java

r2090	r2183
19	19
20	20	import java.util.Collection;
	21	import java.util.HashMap;
21	22	import java.util.Iterator;
22	23	import java.util.LinkedList;
23	24	import java.util.List;
	25	import java.util.Map;
24	26
25	27	import com.sun.fortress.compiler.GlobalEnvironment;
…	…
37	39	import com.sun.fortress.nodes.NonterminalDef;
38	40	import com.sun.fortress.nodes.NonterminalExtensionDef;
	41	import com.sun.fortress.nodes.NonterminalHeader;
	42	import com.sun.fortress.nodes.NonterminalParameter;
	43	import com.sun.fortress.nodes.PrefixedSymbol;
39	44	import com.sun.fortress.nodes.SyntaxDef;
40	45	import com.sun.fortress.nodes.SyntaxSymbol;
…	…
43	48	import com.sun.fortress.nodes.Type;
44	49	import com.sun.fortress.nodes._TerminalDef;
	50	import com.sun.fortress.nodes_util.NodeFactory;
45	51	import com.sun.fortress.syntax_abstractions.environments.GrammarEnv;
46	52	import com.sun.fortress.syntax_abstractions.environments.MemberEnv;
47	53	import com.sun.fortress.syntax_abstractions.environments.SyntaxDeclEnv;
48	54	import com.sun.fortress.syntax_abstractions.intermediate.SyntaxSymbolPrinter;
	55	import com.sun.fortress.syntax_abstractions.rats.util.FreshName;
49	56	import com.sun.fortress.syntax_abstractions.util.SyntaxAbstractionUtil;
50	57
…	…
76	83	private GlobalEnvironment GLOBAL_ENV;
77	84	private CompilationUnitIndex currentApiIndex;
	85	private Map<Id, Id> patternVariablesAndArguments;
78	86
79	87	public TemplateChecker(GlobalEnvironment globalEnv, CompilationUnitIndex currentApiIndex) {
…	…
81	89	this.GLOBAL_ENV = globalEnv;
82	90	this.currentApiIndex = currentApiIndex;
	91	this.patternVariablesAndArguments = new HashMap<Id, Id>();
83	92	}
84	93
…	…
101	110
102	111	@Override
103		public Node forNonterminalDef(NonterminalDef that) {
104		this.currentMemberEnv = GrammarEnv.getMemberEnv(that.getHeader().getName());
105		return super.forNonterminalDef(that);
106		}
107
108		@Override
109		public Node forNonterminalExtensionDef(NonterminalExtensionDef that) {
110		this.currentMemberEnv = GrammarEnv.getMemberEnv(that.getHeader().getName());
111		return super.forNonterminalExtensionDef(that);
112		}
113
114		@Override
115		public Node for_TerminalDef(_TerminalDef that) {
116		this.currentMemberEnv = GrammarEnv.getMemberEnv(that.getHeader().getName());
117		return super.for_TerminalDef(that);
	112	public Node forNonterminalHeader(NonterminalHeader that) {
	113	this.currentMemberEnv = GrammarEnv.getMemberEnv(that.getName());
	114	for (NonterminalParameter np: that.getParams()) {
	115	Id oldName = np.getName();
	116	Id freshName = freshId(oldName);
	117	this.patternVariablesAndArguments.put(oldName, freshName);
	118	}
	119	return super.forNonterminalHeader(that);
118	120	}
119	121
…	…
132	134	}
133	135
134		// Waiting for the new Astgen interface
135		// @Override
136		// public Node forTemplateGap(TemplateGap that) {
137		// handleTemplateGap(that);
138		// return super.forTemplateGap(that);
139		// }
	136	@Override
	137	public Node forPrefixedSymbol(PrefixedSymbol that) {
	138	Id oldName = that.getId().unwrap();
	139	Id freshName = freshId(oldName);
	140	this.patternVariablesAndArguments.put(oldName, freshName);
	141	return super.forPrefixedSymbol(that);
	142	}
	143
	144	private Id freshId(Id oldName) {
	145	return NodeFactory.makeId(FreshName.getFreshName("$"+oldName.getText()+"$"));
	146	}
140	147
141	148	/*
…	…
145	152	*/
146	153	@Override
147		public ~~void handleTemplateGap(TemplateGap gap~~) {
148		~~// System.err.println("handling: "+gap~~.getId());
149
150		if ((this.currentSyntaxDeclEnv.is~~AnyChar(gap~~.getId()) \|\|
151		this.currentSyntaxDeclEnv.is~~CharacterClass(gap~~.getId()) \|\|
152		this.currentSyntaxDeclEnv.getMemberEnv().isParameter(~~gap~~.getId()))
	154	public Node forTemplateGapOnly(TemplateGap that, Id id_result, List<Id> params_result) {
	155	// System.err.println("handling: "+that.getId());
	156
	157	if ((this.currentSyntaxDeclEnv.isCharacterClass(that.getId()) \|\|
	158	this.currentSyntaxDeclEnv.isAnyChar(that.getId()) \|\|
	159	this.currentSyntaxDeclEnv.getMemberEnv().isParameter(that.getId()))
153	160	&&
154		!~~gap~~.getTemplateParams().isEmpty()) {
155		String error = String.format("%s is not applicable",~~gap~~.getId().toString());
156		this.errors.add(StaticError.make(error, ~~gap~~));
157		return;
158		}
159
160		if (!~~gap~~.getTemplateParams().isEmpty()) {
	161	!that.getTemplateParams().isEmpty()) {
	162	String error = String.format("%s is not applicable",that.getId().toString());
	163	this.errors.add(StaticError.make(error, that));
	164	return that;
	165	}
	166
	167	if (!that.getTemplateParams().isEmpty()) {
161	168	String errorMsg = "The nonterminal %1s is not applicable for the arguments (%2s), expected (%3s)";
162		MemberEnv memberEnv = GrammarEnv.getMemberEnv(this.currentSyntaxDeclEnv.getNonterminalName(~~gap~~.getId()));
	169	MemberEnv memberEnv = GrammarEnv.getMemberEnv(this.currentSyntaxDeclEnv.getNonterminalName(that.getId()));
163	170	List<Id> formalParams = memberEnv.getParameters();
164		List<Id> actualParams = ~~gap~~.getTemplateParams();
	171	List<Id> actualParams = that.getTemplateParams();
165	172
166	173	// 1) The number of formal and actual parameters are the same
…	…
168	175	String formals = getFormalParametersList(memberEnv, formalParams);
169	176	String actuals = getActualParametersList(actualParams);
170		String error = String.format(errorMsg, ~~gap~~.getId(), actuals, formals);
171		this.errors.add(StaticError.make(error, ~~gap~~));
	177	String error = String.format(errorMsg, that.getId(), actuals, formals);
	178	this.errors.add(StaticError.make(error, that));
172	179	}
173	180
…	…
199	206	}
200	207	if (isError) {
201		String error = " "+String.format(errorMsg, gap.getId().toString(), actuals, formals);
202		this.errors.add(StaticError.make(error, gap));
203		}
204		}
	208	String error = " "+String.format(errorMsg, that.getId().toString(), actuals, formals);
	209	this.errors.add(StaticError.make(error, that));
	210	}
	211	}
	212
	213	if (!this.patternVariablesAndArguments.containsKey(that.getId())) {
	214	throw new RuntimeException("Unknown pattern variable: "+that.getId());
	215	}
	216
	217	// Id freshName = this.patternVariables.get(gap.getId());
	218	// gap.setId(freshName);
	219	return that;
205	220	}
206	221

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/phases/TemplateParser.java

r2090	r2183
159	159	this.varsToNonterminalType.put(i, new VarType(i.getSpan(), new Id("CharLiteralExpr")));
160	160	}
	161	for (Id i: psg.getCharacterClasses()) {
	162	this.varsToNonterminalType.put(i, new VarType(i.getSpan(), new Id("CharLiteralExpr")));
	163	}
	164	for (Id i: psg.getSpecialSymbols()) {
	165	this.varsToNonterminalType.put(i, new VarType(i.getSpan(), new Id("CharLiteralExpr")));
	166	}
161	167	return super.forPrefixedSymbol(that);
162	168	}

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/util/SyntaxAbstractionUtil.java

r2099	r2183
36	36	import com.sun.fortress.nodes.Id;
37	37	import com.sun.fortress.nodes.TemplateGap;
	38	import com.sun.fortress.nodes.TemplateGapExpr;
38	39	import com.sun.fortress.nodes.VarType;
39	40	import com.sun.fortress.nodes.TraitType;

trunk/ProjectFortress/static_tests/syntax_abstraction/SXXTemplateParamsAreNotApplicable.fsi

r2091	r2183
20	20
21	21	grammar A
22		Foo(e:LooseJuxt) :Expr:= ~~foo <[ e~~(foo) ]>
	22	Foo(e:LooseJuxt) :Expr:= b:[ab] foo a:_ <[ e(foo) a(foo) b(foo) ]>
23	23	end
24	24

trunk/ProjectFortress/static_tests/syntax_abstraction/SyntaxRepetition.fsi

r2123	r2183
32	32	grammar Select1 extends { A, B, Expression }
33	33	Expr \|Expr:=
34		SELECT ATuples* world
	34	SELECT tuples:ATuples* world
35	35	do
36	36	(* GrammarHelper().makeObjectInstance(ATuples) *)
37		exprs:List[\Expr\] = emptyList[\Expr\](2);
38		ids:List[\Id\] = emptyList[\Id\]();
39		ids1:List[\Id\] = ids.addRight(Id(Nothing[\APIName\], "SyntaxRepetition"));
40		apiName:APIName = APIName(ids1);
41		typeName:String = "" "SelectQuery";
42		name:Id = Id(Just[\APIName\](apiName), typeName);
43		exprs1:List[\Expr\] = exprs.addRight(FnRef( <\| name \|> , emptyList[\StaticArg\]()));
44		ops1:List[\OpName\] = emptyList[\OpName\](1);
45		ops2:List[\OpName\] = ops1.addRight(Enclosing(Op(Nothing[\APIName\], "<\|", Just[\Fixity\](EnclosingFixity())), Op(Nothing[\APIName\],"\|>", Just[\Fixity\](EnclosingFixity()))));
46		op:OpRef = OpRef(ops2, emptyList[\StaticArg\]());
47		opExpr:OpExpr = OpExpr(op, ATuples)
48		exprs2:List[\Expr\] = exprs1.addRight(opExpr);
49		TightJuxt(exprs2)
	37	exprs:List[\Expr\] = emptyList[\Expr\](2)
	38	ids:List[\Id\] = emptyList[\Id\]()
	39	ids1:List[\Id\] = ids.addRight(Id(Nothing[\APIName\], "SyntaxRepetition"))
	40	apiName:APIName = APIName(ids1)
	41	typeName:String = "" "SelectQuery"
	42	name:Id = Id(Just[\APIName\](apiName), typeName)
	43	staticArgs:List[\StaticArg\] = emptyList[\StaticArg\]()
	44	names:List[\Id\] = <\| name \|>
	45	exprs1:List[\Expr\] = exprs.addRight(FnRef(1, name, names, staticArgs))
	46
	47	in_api:Maybe[\APIName\] = Nothing[\APIName\]
	48	open:Op = Op(Nothing[\APIName\], "<\|", Just[\Fixity\](EnclosingFixity))
	49	close:Op = Op(Nothing[\APIName\],"\|>", Just[\Fixity\](EnclosingFixity))
	50	enclosing:Enclosing = Enclosing(in_api, open, close)
	51	ops1:List[\OpName\] = emptyList[\OpName\](1)
	52	ops2:List[\OpName\] = ops1.addRight(enclosing)
	53	listStaticArgs1:List[\StaticArg\] = emptyList[\StaticArg\]()
	54	fortressBuiltin1:List[\Id\] = emptyList[\Id\]()
	55	fortressBuiltin2:List[\Id\] = fortressBuiltin1.addRight(Id(Nothing[\APIName\], "FortressBuiltin"))
	56	fortressBuiltin:APIName = APIName(fortressBuiltin2)
	57	stringId:Id = Id(Just[\APIName\](fortressBuiltin), "String")
	58	stringType:Type = TraitType(stringId, 1, emptyList[\StaticArg\]())
	59	typeArg:TypeArg = TypeArg(stringType)
	60	listStaticArgs:List[\StaticArg\] = emptyList[\StaticArg\]()
	61	listStaticArgs2:List[\StaticArg\] = listStaticArgs.addRight(typeArg);
	62	op:OpRef = OpRef(1, enclosing, ops2, listStaticArgs)
	63	opExpr:OpExpr = OpExpr(op, tuples)
	64	exprs2:List[\Expr\] = exprs1.addRight(opExpr)
	65
	66	multiFix:Op = Op(Nothing[\APIName\], "juxtaposition", Just[\Fixity\](MultiFixity))
	67	multifix1:List[\OpName\] = emptyList[\OpName\]()
	68	multifix2:List[\OpName\] = multifix1.addRight(multiFix)
	69	multiFixOpRef:OpRef = OpRef(1, multiFix, multifix2, emptyList[\StaticArg\]())
	70	inFix:Op = Op(Nothing[\APIName\], "juxtaposition", Just[\Fixity\](InFixity))
	71	infix1:List[\OpName\] = emptyList[\OpName\]()
	72	infix2:List[\OpName\] = infix1.addRight(inFix)
	73	inFixOpRef:OpRef = OpRef(1, inFix, infix2, emptyList[\StaticArg\]())
	74	TightJuxt(multiFixOpRef, inFixOpRef, exprs2)
	75
50	76	end
51	77	\| SELECT BTuples* world
52	78	do
53		exprs:List[\Expr\] = emptyList[\Expr\](2);
54		ids:List[\Id\] = emptyList[\Id\]();
55		ids1:List[\Id\] = ids.addRight(Id(Nothing[\APIName\], "SyntaxRepetition"));
56		apiName:APIName = APIName(ids1);
57		typeName:String = "" "SelectQuery";
58		name:Id = Id(Just[\APIName\](apiName), typeName);
59		exprs1:List[\Expr\] = exprs.addRight(FnRef( <\| name \|> , emptyList[\StaticArg\]()));
60		ops1:List[\OpName\] = emptyList[\OpName\](1);
61		ops2:List[\OpName\] = ops1.addRight(Enclosing(Op(Nothing[\APIName\], "<\|", Just[\Fixity\](EnclosingFixity())), Op(Nothing[\APIName\],"\|>", Just[\Fixity\](EnclosingFixity()))));
62		op:OpRef = OpRef(ops2, emptyList[\StaticArg\]());
	79	StringLiteralExpr("BBBB")
	80	(* exprs:List[\Expr\] = emptyList[\Expr\](2)
	81	ids:List[\Id\] = emptyList[\Id\]()
	82	ids1:List[\Id\] = ids.addRight(Id(Nothing[\APIName\], "SyntaxRepetition"))
	83	apiName:APIName = APIName(ids1)
	84	typeName:String = "" "SelectQuery"
	85	name:Id = Id(Just[\APIName\](apiName), typeName)
	86	names:List[\Id\] = <\| name \|>
	87	staticArgs:List[\StaticArg\] = emptyList[\StaticArg\]()
	88	exprs1:List[\Expr\] = exprs.addRight(FnRef(1, name, names, staticArgs))
	89
	90
	91	in_api:Maybe[\APIName\] = Nothing[\APIName\]
	92	open:Op = Op(Nothing[\APIName\], "<\|", Just[\Fixity\](EnclosingFixity))
	93	close:Op = Op(Nothing[\APIName\],"\|>", Just[\Fixity\](EnclosingFixity))
	94	enclosing:Enclosing = Enclosing(in_api, open, close)
	95	ops1:List[\OpName\] = emptyList[\OpName\](1)
	96	ops2:List[\OpName\] = ops1.addRight(enclosing)
	97	op:OpRef = OpRef(1, enclosing, ops2, emptyList[\StaticArg\]())
63	98	opExpr:OpExpr = OpExpr(op, BTuples)
64		exprs2:List[\Expr\] = exprs1.addRight(opExpr);
65		TightJuxt(exprs2)
	99	exprs2:List[\Expr\] = exprs1.addRight(opExpr)
	100
	101	multiFix:Op = Op(Nothing[\APIName\], "juxtaposition", Just[\Fixity\](MultiFixity))
	102	multifix1:List[\OpName\] = emptyList[\OpName\]()
	103	multifix2:List[\OpName\] = multifix1.addRight(multiFix)
	104	multiFixOpRef:OpRef = OpRef(1, multiFix, multifix2, emptyList[\StaticArg\]())
	105	inFix:Op = Op(Nothing[\APIName\], "juxtaposition", Just[\Fixity\](InFixity))
	106	infix1:List[\OpName\] = emptyList[\OpName\]()
	107	infix2:List[\OpName\] = infix1.addRight(inFix)
	108	inFixOpRef:OpRef = OpRef(1, inFix, infix2, emptyList[\StaticArg\]())
	109	TightJuxt(multiFixOpRef, inFixOpRef, exprs2)
	110	*)
66	111	end
67	112	end
…	…
81	126	exprs1:List[\Expr\] = exprs.addRight(StringLiteralExpr(""))
82	127	exprs2:List[\Expr\] = exprs1.addRight(StringLiteralExpr(a.in_text))
83		LooseJuxt(exprs2) end
	128	multiFix:Op = Op(Nothing[\APIName\], "juxtaposition", Just[\Fixity\](MultiFixity))
	129	multifix1:List[\OpName\] = emptyList[\OpName\]()
	130	multifix2:List[\OpName\] = multifix1.addRight(multiFix)
	131	multiFixOpRef:OpRef = OpRef(1, multiFix, multifix2, emptyList[\StaticArg\]())
	132	inFix:Op = Op(Nothing[\APIName\], "juxtaposition", Just[\Fixity\](InFixity))
	133	infix1:List[\OpName\] = emptyList[\OpName\]()
	134	infix2:List[\OpName\] = infix1.addRight(inFix)
	135	inFixOpRef:OpRef = OpRef(1, inFix, infix2, emptyList[\StaticArg\]())
	136	LooseJuxt(multiFixOpRef, inFixOpRef, exprs2)
	137	end
84	138	end
85	139

trunk/ProjectFortress/static_tests/syntax_abstraction/SyntaxRepetitionUse.fss

r1650	r2183
23	23
24	24	run(args:String...) = do
25		print (SELECT a a a from)
26		print (SELECT b b b b from)
27		print (SELECT a a a a world)
28		print (SELECT b b world)
	25	println (SELECT a a a from)
	26	println (SELECT b b b b from)
	27	println (SELECT world)
	28	(* println (SELECT b b world) *)
	29	println 42
29	30	end
30	31	end

Navigation

Changeset 2183

Legend:

Download in other formats: