public UnifiedType WrapGeneric(
UnifiedSet<UnifiedGenericArgument> arguments = null)
{
return new UnifiedGenericType {
Type = this,
Arguments = arguments,
};
}
public override bool Visit(
UnifiedSet<UnifiedCase> element, VisitorArgument arg)
{
arg = arg.IncrementDepth();
foreach (var caseElement in element) {
WriteIndent(arg.IndentDepth);
caseElement.TryAccept(this, arg);
}
return false;
}
public override bool Visit(
UnifiedSet <UnifiedCase> element, VisitorArgument arg)
{
arg = arg.IncrementDepth();
foreach (var caseElement in element)
{
WriteIndent(arg.IndentDepth);
caseElement.TryAccept(this, arg);
}
return(false);
}
public override MutableSet <V> Collect <V, T1>(LongToObjectFunction <T1> function) where T1 : V
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.MutableSet<V> result = new org.eclipse.collections.impl.set.mutable.UnifiedSet<>(size());
MutableSet <V> result = new UnifiedSet <V>(Size());
Each(element =>
{
result.add(function.apply(element));
});
return(result);
}
// e.g. Foo<T1, T2> where T1 : string
public override bool Visit(
UnifiedSet<UnifiedGenericParameter> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(InequalitySignParen));
foreach (var genericParameter in element) {
if (genericParameter.Constrains != null) {
foreach (var constrain in genericParameter.Constrains) {
Writer.Write(" where ");
genericParameter.Type.TryAccept(this, arg);
constrain.TryAccept(this, arg.Set(ColonDelimiter));
}
}
}
return false;
}
public override bool Visit(
UnifiedSet<UnifiedCatch> element, VisitorArgument arg)
{
//TODO VisitCollection()に置き換えられるか確認
Writer.Write(arg.Decoration.MostLeft);
var delimiter = "";
foreach (var e in element) {
Writer.Write(delimiter);
e.TryAccept(this, arg);
delimiter = arg.Decoration.Delimiter;
}
Writer.Write(arg.Decoration.MostRight);
return false;
}
public static UnifiedSet <UnifiedParameter> CreateDeclaratorSuffix(
XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "declarator_suffix");
/* declarator_suffix
* : '[' constant_expression ']'
* | '[' ']'
* | '(' parameter_type_list ')'
* | '(' identifier_list ')'
* | '(' ')'
* ;
*/
// 空のパラメータリストを生成する
var parameters = UnifiedSet <UnifiedParameter> .Create();
// ()の場合
if (node.FirstElement().Value.Equals("(") &&
node.LastElement().Value.Equals(")"))
{
if (node.Element("parameter_type_list") != null)
{
parameters =
CreateParameterTypeList(
node.Element("parameter_type_list"));
}
else if (node.Element("identifier_list") != null)
{
// TODO どう考えてもargumentCollectionだが、対応するプログラムをまずは検証する
throw new NotImplementedException();
}
// []の場合
}
else if (node.FirstElement().Value.Equals("[") &&
node.LastElement().Value.Equals("]"))
{
// TODO []がくるケースがまだ未検証
throw new NotImplementedException();
}
else
{
throw new InvalidOperationException();
}
return(parameters);
}
CreateSpecifierQualifierList(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "specifier_qualifier_list");
/*
* specifier_qualifier_list
* : ( type_qualifier | type_specifier )+
*/
var modifiers = UnifiedSet <UnifiedModifier> .Create();
var types = new List <UnifiedType>();
foreach (var e in node.Elements())
{
switch (e.Name())
{
case "type_qualifier":
modifiers.Add(CreateTypeQualifier(e));
break;
case "type_specifier":
types.Add((UnifiedType)CreateTypeSpecifier(e));
break;
}
}
// 修飾子が空の場合はnullにする
if (modifiers.IsEmpty())
{
modifiers = null;
}
var s = "";
var prefix = "";
foreach (var t in types)
{
s += prefix + t.BasicTypeName;
prefix = " ";
}
var type = s.Equals("")
? null
: UnifiedType.Create(
UnifiedVariableIdentifier.Create(s));
return(Tuple.Create(modifiers, type));
}
// Expressions
public static UnifiedSet <UnifiedArgument> CreateArgumentExpressionList(
XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "argument_expression_list");
/*
* argument_expression_list
* : assignment_expression (',' assignment_expression)*
*/
var arguments = node.Elements("assignment_expression").
Select(CreateAssignmentExpression).
Select(e => UnifiedArgument.Create(e));
return(UnifiedSet <UnifiedArgument> .Create(arguments));
}
public static UnifiedFunctionDefinition CreateFunctionDefinition(
XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "function_definition");
/* function_definition
* : declaration_specifiers? declarator
* ( declaration+ compound_statement // K&R style
* | compound_statement // ANSI style
* )
*/
UnifiedSet <UnifiedModifier> modifiers = null;
UnifiedType type = null;
UnifiedSet <UnifiedGenericParameter> genericParameters = null;
UnifiedIdentifier name = null;
UnifiedSet <UnifiedParameter> parameters = null;
UnifiedBlock body = null;
var first = node.FirstElement();
if (first.Name() == "declaration_specifiers")
{
var modifiersAndType = CreateDeclarationSpecifiers(first);
modifiers = modifiersAndType.Item1;
type = (UnifiedType)modifiersAndType.Item2;
}
var declarator = CreateDeclarator(node.Element("declarator"));
name = declarator.Item1;
parameters = declarator.Item2;
if (node.Elements("declaration").Count() != 0)
{
// TODO declaration+ compound_statement に該当するケースが未検出
throw new NotImplementedException();
}
body = CreateCompoundStatement(node.Element("compound_statement"));
return(UnifiedFunctionDefinition.Create(
null, modifiers, type, genericParameters, name, parameters,
null, body));
}
public override bool Visit(
UnifiedSet <UnifiedCatch> element, VisitorArgument arg)
{
//TODO VisitCollection()に置き換えられるか確認
Writer.Write(arg.Decoration.MostLeft);
var delimiter = "";
foreach (var e in element)
{
Writer.Write(delimiter);
e.TryAccept(this, arg);
delimiter = arg.Decoration.Delimiter;
}
Writer.Write(arg.Decoration.MostRight);
return(false);
}
// e.g. Foo<T1, T2> where T1 : string
public override bool Visit(
UnifiedSet <UnifiedGenericParameter> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(InequalitySignParen));
foreach (var genericParameter in element)
{
if (genericParameter.Constrains != null)
{
foreach (var constrain in genericParameter.Constrains)
{
Writer.Write(" where ");
genericParameter.Type.TryAccept(this, arg);
constrain.TryAccept(this, arg.Set(ColonDelimiter));
}
}
}
return(false);
}
public void compares_different_calls()
{
var o1 =
UnifiedCall.Create(
UnifiedVariableIdentifier.Create("f"),
UnifiedSet <UnifiedArgument> .Create(
UnifiedArgument.Create(
UnifiedVariableIdentifier.Create(
"a"), null, null),
UnifiedArgument.Create(
UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.
Create("n"),
UnifiedBinaryOperator.Create
(
"-",
UnifiedBinaryOperatorKind
.Add),
UnifiedInt32Literal.Create(
1)
), null, null)));
var o2 =
UnifiedCall.Create(
UnifiedVariableIdentifier.Create("f"),
UnifiedSet <UnifiedArgument> .Create(
UnifiedArgument.Create(
UnifiedVariableIdentifier.Create(
"a"), null, null),
UnifiedArgument.Create(
UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.
Create("n2"),
UnifiedBinaryOperator.Create
(
"-",
UnifiedBinaryOperatorKind
.Add),
UnifiedInt32Literal.Create(
1)), null, null)));
Assert.That(
StructuralEqualityComparer.StructuralEquals(o1, o2),
Is.False);
}
public override bool Visit(
UnifiedSet <UnifiedTypeConstrain> element, VisitorArgument arg)
{
UnifiedTypeConstrain last = null;
foreach (var current in element)
{
if (last == null)
{
current.TryAccept(this, arg.Set(NullDelimiter));
}
else
{
current.TryAccept(this, arg.Set(ColonDelimiter));
}
last = current;
}
return(false);
}
CreateDirectDeclarator(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "direct_declarator");
/* direct_declarator
* : ( IDENTIFIER | '(' declarator ')' ) declarator_suffix*
*/
var identifier = node.Element("IDENTIFIER");
UnifiedIdentifier name;
if (identifier != null)
{
name = UnifiedVariableIdentifier.Create(identifier.Value);
}
else if (node.Element("declarator") != null)
{
// TODO (test())(){ }が許されるとして、その場合はどうするのか
return(CreateDeclarator(node.Element("declarator")));
}
else
{
throw new InvalidOperationException();
}
UnifiedSet <UnifiedParameter> parameters = null;
if (node.Elements("declarator_suffix").Count() > 1)
{
// TODO test()()となるケースが未検出
throw new NotImplementedException();
}
else if (node.Elements("declarator_suffix").Count() == 1)
{
parameters =
CreateDeclaratorSuffix(
node.Element("declarator_suffix"));
}
return(Tuple.Create(name, parameters));
}
public static UnifiedSet <UnifiedParameter> CreateParameterList(
XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "parameter_list");
/*
* parameter_list
* : parameter_declaration (',' parameter_declaration)*
*/
var parameters = UnifiedSet <UnifiedParameter> .Create();
foreach (var parameterNode in node.Elements("parameter_declaration")
)
{
parameters.Add(CreateParameterDeclaration(parameterNode));
}
return(parameters);
}
private static UnifiedCatch CreateResbody(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "resbody");
Contract.Requires(node.FirstElement().Name() == "array");
// TODO: UnifiedType.Create(ident) => identをUnifiedTypeIdentifierにべきでは？
var children = node.FirstElement().Elements().ToList();
var block = CreateSmartBlock(node.LastElement());
if (children.Count == 0)
{
return(UnifiedCatch.Create(
UnifiedSet <UnifiedType> .Create(), null, block));
}
var assign = CreateExpresion(children.Last().FirstElement());
var types = children.SkipLast()
.Select(CreateConst)
.Select(UnifiedType.Create)
.ToSet();
return(UnifiedCatch.Create(types, assign, block));
}
public static UnifiedSet <UnifiedParameter> CreateParameterTypeList(
XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "parameter_type_list");
/*
* parameter_type_list
* : parameter_list (',' '...')?
*/
var parameters = CreateParameterList(node.Element("parameter_list"));
// TODO 可変長引数はmodifierなのか確認
if (node.LastElement().Value == "...")
{
parameters.Add(
UnifiedParameter.Create(
modifiers:
UnifiedSet <UnifiedModifier> .Create(
UnifiedModifier.Create("..."))));
}
return(parameters);
}
//JavaScriptでは型パラメータは出現しない
public override bool Visit(
UnifiedSet <UnifiedGenericParameter> element, VisitorArgument arg)
{
return(false);
}
//JavaScriptでは例外型の列挙は出現しない
public override bool Visit(
UnifiedSet <UnifiedType> element, VisitorArgument arg)
{
return(false);
}
//現在は使用されていない
public override bool Visit(
UnifiedSet <UnifiedExpression> element, VisitorArgument arg)
{
throw new InvalidOperationException();
}
CreateDeclarationSpecifiers(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "declaration_specifiers");
/* declaration_specifiers
* : ( storage_class_specifier
* | type_specifier
* | type_qualifier )+
*/
var modifiers = UnifiedSet <UnifiedModifier> .Create();
IList <UnifiedType> types = new List <UnifiedType>();
UnifiedExpression declaration = null;
foreach (var e in node.Elements())
{
switch (e.Name())
{
case "storage_class_specifier":
modifiers.Add(CreateStorageClassSpecifier(e));
break;
case "type_specifier":
var typeSpecifier = CreateTypeSpecifier(e);
if (typeSpecifier.GetType().Equals(typeof(UnifiedType)))
{
types.Add((UnifiedType)CreateTypeSpecifier(e));
}
else
{
declaration = typeSpecifier;
}
break;
case "type_qualifier":
//TODO: const または volatileのことであるが、安直にリストに追加していいか要確認
modifiers.Add(CreateTypeQualifier(e));
break;
default:
throw new InvalidOperationException();
}
}
// 修飾子が空の場合はnullにする
if (modifiers.IsEmpty())
{
modifiers = null;
}
if (declaration != null)
{
return(Tuple.Create(modifiers, declaration));
}
UnifiedExpression type;
if (types.Count == 1)
{
type = types[0];
}
else
{
var s = "";
var prefix = "";
// TODO unsigned int, long long int などは そのまま１つの型で表されるのか？
foreach (var t in types)
{
s += prefix
+ ((UnifiedVariableIdentifier)t.BasicTypeName).Name;
prefix = " ";
}
type = UnifiedType.Create(UnifiedVariableIdentifier.Create(s));
}
return(Tuple.Create(modifiers, type));
}
//現在は使用されていない
public override bool Visit(
UnifiedSet<UnifiedExpression> element, VisitorArgument arg)
{
throw new InvalidOperationException();
}
public override bool Visit(
UnifiedSet<UnifiedModifier> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(SpaceDelimiter));
return false;
}
public override bool Visit(
UnifiedSet<UnifiedTypeConstrain> element, VisitorArgument arg)
{
UnifiedTypeConstrain last = null;
foreach (var current in element) {
if (last == null) {
current.TryAccept(this, arg.Set(NullDelimiter));
} else {
current.TryAccept(this, arg.Set(ColonDelimiter));
}
last = current;
}
return false;
}
// e.g. Foo<A, B> ?
public override bool Visit(
UnifiedSet <UnifiedGenericParameter> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(InequalitySignParen));
return(false);
}
public override bool Visit(
UnifiedSet<UnifiedAnnotation> element, VisitorArgument arg)
{
return false;
}
public static UnifiedVariableDefinition CreateVariableDeclarator
(
XElement node, UnifiedSet<UnifiedAnnotation> annotations,
UnifiedSet<UnifiedModifier> modifiers, UnifiedType type) {
Contract.Requires(node != null);
Contract.Requires(node.Name() == "variableDeclarator");
/*
* variableDeclarator
* : IDENTIFIER ('[' ']')* ('=' variableInitializer)?
*/
var initializer = node.HasElement("variableInitializer")
? CreateVariableInitializer(
node.Element(
"variableInitializer"))
: null;
var dimension = node.ElementsByContent("[").Count();
type = type.WrapArrayRepeatedly(dimension);
return UnifiedVariableDefinition.Create(
annotations, modifiers, type,
UnifiedVariableIdentifier.Create(node.FirstElement().Value),
initializer
);
}
//継承 : JavaScriptでは出現しない
public override bool Visit(
UnifiedSet<UnifiedTypeConstrain> element, VisitorArgument arg)
{
return false;
}
public override bool Visit(
UnifiedSet<UnifiedExpression> element, VisitorArgument arg)
{
VisitCollection(element, arg);
return false;
}
public UnifiedType WrapRectangleArray(
UnifiedSet<UnifiedArgument> arguments = null)
{
return new UnifiedArrayType {
Type = this,
Arguments = arguments,
};
}
public override bool Visit(
UnifiedSet <UnifiedIdentifier> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(CommaDelimiter));
return(false);
}
public UnifiedElement VisitTypeDeclaration(
TypeDeclaration dec, object data)
{
var attrs = dec.Attributes.AcceptVisitorAsAttrs(this, data);
var mods = LookupModifiers(dec.Modifiers);
var name = UnifiedVariableIdentifier.Create(dec.Name);
var typeParams = dec.TypeParameters.AcceptVisitorAsTypeParams(
this, data);
if (typeParams.Count == 0)
{
typeParams = null;
}
var extends = dec.BaseTypes.AcceptVisitorAsConstrains(this, data);
var body = UnifiedBlock.Create();
foreach (var node in dec.Members)
{
var uExpr = node.TryAcceptForExpression(this);
if (uExpr != null)
{
body.Add(uExpr);
}
}
// set constraint
var dic = CreateDictionary(dec.Constraints);
if (typeParams != null)
{
foreach (
var generic in
typeParams.Descendants <UnifiedGenericParameter>(
))
{
var tName = GetTypeName(generic.Type);
if (dic.ContainsKey(tName))
{
foreach (var c in dic[tName])
{
if (generic.Constrains == null)
{
generic.Constrains =
UnifiedSet <UnifiedTypeConstrain> .Create();
}
generic.Constrains.Add(c.DeepCopy());
}
}
}
}
foreach (
var generic in
extends.Descendants <UnifiedGenericParameter>())
{
var tName = GetTypeName(generic.Type);
if (dic.ContainsKey(tName))
{
foreach (var c in dic[tName])
{
if (generic.Constrains == null)
{
generic.Constrains =
UnifiedSet <UnifiedTypeConstrain> .Create();
}
generic.Constrains.Add(c.DeepCopy());
}
}
}
switch (dec.ClassType)
{
case ClassType.Class:
return(UnifiedClassDefinition.Create(
attrs, mods, name, typeParams, extends, body));
case ClassType.Struct:
return(UnifiedStructDefinition.Create(
attrs, mods, name, typeParams, extends, body));
case ClassType.Interface:
return(UnifiedInterfaceDefinition.Create(
attrs, mods, name, typeParams, extends, body));
case ClassType.Enum:
return(UnifiedEnumDefinition.Create(
attrs, mods, name, typeParams, extends, body));
}
var msg = "LookupClassKind : " + dec.ClassType + "には対応していません。";
throw new InvalidOperationException(msg);
}
public override bool Visit(
UnifiedSet <UnifiedArgument> element, VisitorArgument arg)
{
VisitCollection(element, arg);
return(false);
}
public override bool Visit(
UnifiedSet<UnifiedParameter> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(Paren));
return false;
}
public override bool Visit(
UnifiedSet <UnifiedParameter> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(Paren));
return(false);
}
// e.g. {...}catch(Exception1 e1){...}catch{Exception2 e2}{....}... ?
public override bool Visit(
UnifiedSet<UnifiedCatch> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(NewLineDelimiter));
return false;
}
//JavaScriptでは修飾子は出現しない
public override bool Visit(
UnifiedSet<UnifiedModifier> element, VisitorArgument arg)
{
return false;
}
public override bool Visit(
UnifiedSet<UnifiedGenericArgument> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(InequalitySignParen));
return false;
}
//JavaScriptでは型パラメータは出現しない
public override bool Visit(
UnifiedSet<UnifiedGenericParameter> element, VisitorArgument arg)
{
return false;
}
public override bool Visit(
UnifiedSet <UnifiedModifier> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(SpaceEachRight));
return(false);
}
// e.g. throws E1, E2 ...
public override bool Visit(
UnifiedSet <UnifiedType> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(Throws));
return(false);
}
public static UnifiedExpression CreatePostfixExpression(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "postfix_expression");
/*
* postfix_expression
* : primary_expression
* ( '[' expression ']'
| '(' ')'
| '(' argument_expression_list ')'
| '.' IDENTIFIER
| '->' IDENTIFIER
| '++'
| '--'
| )*
*/
var result =
CreatePrimaryExpression(node.Element("primary_expression"));
var elements = node.Elements().Skip(1); //先頭以外のすべての要素を取得
var length = elements.Count();
for (var i = 0; i < length; i++)
{
switch (elements.ElementAt(i++).Value)
{
case "[":
result = UnifiedIndexer.Create(
result,
UnifiedSet <UnifiedArgument> .Create(
UnifiedArgument.Create(
CreateExpression(
elements.ElementAt(i++)).
ElementAt(0))));
i++; // ']'読み飛ばし
break;
case "(":
if (elements.ElementAt(i).Name == "argument_expression_list")
{
result = UnifiedCall.Create(
result,
CreateArgumentExpressionList(
elements.ElementAt(i++)));
}
else
{
result = UnifiedCall.Create(
result, UnifiedSet <UnifiedArgument> .Create());
}
i++; // ')'読み飛ばし
break;
case ".":
result = UnifiedProperty.Create(
".", result,
UnifiedIdentifier.CreateVariable(
elements.ElementAt(i++).Value));
break;
case "->":
result = UnifiedProperty.Create(
"->", result,
UnifiedIdentifier.CreateVariable(
elements.ElementAt(i++).Value));
// TODO ポインタ型に展開してから処理するのか？
break;
case "++":
result = UnifiedUnaryExpression.Create(
result,
UnifiedUnaryOperator.Create(
"++",
UnifiedUnaryOperatorKind.PostIncrementAssign));
break;
case "--":
result = UnifiedUnaryExpression.Create(
result,
UnifiedUnaryOperator.Create(
"--",
UnifiedUnaryOperatorKind.PostDecrementAssign));
break;
default:
throw new InvalidOperationException();
}
}
return(result);
}
// e.g. {...}catch(Exception1 e1){...}catch{Exception2 e2}{....}... ?
public override bool Visit(
UnifiedSet <UnifiedCatch> element, VisitorArgument arg)
{
VisitCollection(element, arg.Set(NewLineDelimiter));
return(false);
}
private void AssertContains(IEnumerable <NodeWithPropertyValues> iterable, params NodeWithPropertyValues[] expected)
{
assertEquals(UnifiedSet.newSetWith(expected), UnifiedSet.newSet(iterable));
}
public static UnifiedExpression CreateSelectionStatement(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "selection_statement");
/*
* selection_statement
* : 'if' '(' expression ')' statement (options {k=1; backtrack=false;}:'else' statement)?
| 'switch' '(' expression ')' statement
*/
// TODO switch文のstatementについて、{}がないと単一のstatementしか取得できないため対応を考える
// TODO switchNest.c
switch (node.FirstElement().Value)
{
case "if":
var statements = node.Elements("statement");
var trueBlock = CreateStatement(statements.ElementAt(0));
// statementが２つある場合はelse文がある
if (statements.Count() == 2)
{
return
(UnifiedIf.Create(
CreateExpression(node.NthElement(2)).First(),
trueBlock.ToBlock(),
CreateStatement(statements.ElementAt(1)).
ToBlock()));
}
return
(UnifiedIf.Create(
CreateExpression(node.NthElement(2)).First(),
trueBlock.ToBlock()));
case "switch":
// statementの中身を解析して、この関数内で直接UnifiedCaseを生成します。
// labeled_statementから辿って、このノードに到達するまでにlabeled_statementがなければ、
// そのlabeled_statementはこのノードのケース文です
var cases = UnifiedSet <UnifiedCase> .Create();
var labels = node.DescendantsAndSelf("labeled_statement")
// Ignore label statements for goto
.Where(e => e.FirstElement().Name != "IDENTIFIER")
// Ignore label statements of nested switches
.Where(
e =>
!e.AncestorsUntil(node).Any(
e2 =>
e2.Name == "selection_statement" &&
e2.Value.StartsWith("switch")));
foreach (var e in labels)
{
cases.Add(CreateCaseOrDefault(e));
}
return
(UnifiedSwitch.Create(
CreateExpression(node.NthElement(2)).First(),
cases));
default:
throw new InvalidOperationException();
}
}
