private static string GetTypeName(UnifiedType type)
{
Contract.Requires(type != null);
var ident = type.BasicTypeName as UnifiedIdentifier;
if (ident == null)
{
return(null);
}
return(ident.Name);
}
public static UnifiedType CreateTypeId(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "type_id");
/*
* type_id
* : {isTypeName(input.LT(1).getText())}? IDENTIFIER
*/
// typedefされた型名が使用される場合
return(UnifiedType.Create(node.Elements().First().Value));
}
public static UnifiedClassDefinition CreateClass(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "class");
var constNode = node.NthElement(1);
var constrain = constNode.Name() != "nil"
? UnifiedExtendConstrain.Create(
UnifiedType.Create(constNode.Value))
: null;
return(UnifiedClassDefinition.Create(
null, null, CreateSymbol(node.NthElement(0)), null,
constrain.ToSet <UnifiedTypeConstrain>(),
CreateScope(node.NthElement(2))));
}
public UnifiedElement VisitSimpleType(
SimpleType simpleType, object data)
{
var type = UnifiedType.Create(simpleType.Identifier);
// TODO: Send a Patch to NRefactory
if (ReferenceEquals(simpleType.TypeArguments, null))
{
return(type);
}
var uTypeArgs =
simpleType.TypeArguments.AcceptVisitorAsTypeArgs(this, data);
return(type.WrapGeneric(uTypeArgs));
}
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));
}
public static UnifiedType CreateStructOrUnionSpecifier(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "struct_or_union_specifier");
/* struct_or_union_specifier
* : struct_or_union IDENTIFIER? '{' struct_declaration_list '}'
* | struct_or_union IDENTIFIER
*/
// 構造体の定義と宣言の両方をこのメソッドで作成
// 常に UnifiedType を返すが、
// 構造体定義をしている場合だけ関数の呼び出し元で UnifiedType の中身をとりだす
// typedef "struct {}" data; -> クラス？
// "struct data {}"; -> クラス
// "struct data" a; -> 型
var isStruct = CreateStructOrUnion(node.FirstElement()) == "struct";
var identifier = node.Element("IDENTIFIER");
var typeName = identifier == null
? null
: UnifiedVariableIdentifier.Create(
identifier.Value);
// 型の場合
if (node.Elements().Count() == 2)
{
var baseType = UnifiedType.Create(typeName);
return(isStruct ? baseType.WrapStruct() : baseType.WrapUnion());
}
// struct or union の定義がある場合
var body =
CreateStructDeclarationList(
node.Element("struct_declaration_list"));
var structOrUnion = isStruct
? (UnifiedClassLikeDefinition)
UnifiedStructDefinition.
Create(
name: typeName,
body: body)
: UnifiedUnionDefinition.Create(
name: typeName, body: body);
// TODO struct or unionはあくまでもTypeとして返すののか？
return(UnifiedType.Create(structOrUnion));
}
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));
}
internal static UnifiedType LookupType(AstType type)
{
Contract.Requires <ArgumentNullException>(type != null);
Contract.Ensures(Contract.Result <UnifiedType>() != null);
var prim = type as PrimitiveType;
if (prim != null)
{
return(UnifiedType.Create(prim.Keyword));
}
var sim = type as SimpleType;
if (sim != null)
{
return(UnifiedType.Create(sim.Identifier));
}
var com = type as ComposedType;
if (com != null)
{
var uType = LookupType(com.BaseType);
foreach (var aSpec in com.ArraySpecifiers)
{
uType = uType.WrapRectangleArray(aSpec.Dimensions);
}
return(uType);
}
var mem = type as MemberType;
if (mem != null)
{
var target = LookupType(mem.Target);
var name = mem.MemberName.ToVariableIdentifier();
return
(UnifiedType.Create(
UnifiedProperty.Create(".", target, name)));
}
if (type == AstType.Null)
{
return(UnifiedType.Create());
}
throw new NotImplementedException("LookupType");
}
public UnifiedElement VisitMemberType(
MemberType memberType, object data)
{
var ident = UnifiedTypeIdentifier.Create(memberType.MemberName);
var target = memberType.Target.TryAcceptForExpression(this);
var uProp =
UnifiedType.Create(
UnifiedProperty.Create(".", target, ident));
// TODO: Send a Patch to NRefactory
if (ReferenceEquals(memberType.TypeArguments, null))
{
return(uProp);
}
var uTypeArgs =
memberType.TypeArguments.AcceptVisitorAsTypeArgs(this, data);
return(uProp.WrapGeneric(uTypeArgs));
}
public UnifiedElement VisitTypeParameterDeclaration(
TypeParameterDeclaration dec, object data)
{
var type = UnifiedType.Create(dec.Name);
var modifiers = null as UnifiedSet <UnifiedModifier>;
switch (dec.Variance)
{
case VarianceModifier.Contravariant:
modifiers = UnifiedModifier.Create("in").ToSet();
break;
case VarianceModifier.Covariant:
modifiers = UnifiedModifier.Create("out").ToSet();
break;
}
return(UnifiedGenericParameter.Create(
type, /*constraint*/ null, modifiers));
}
public static UnifiedExpression CreateTypeSpecifier(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "type_specifier");
/* type_specifier
* : 'void'
* | 'char'
* | 'short'
* | 'int'
* | 'long'
* | 'float'
* | 'double'
* | 'signed'
* | 'unsigned'
* | struct_or_union_specifier
* | enum_specifier
* | type_id
*/
var first = node.FirstElement();
switch (first.Name())
{
case "struct_or_union_specifier":
return(CreateStructOrUnionSpecifier(first));
case "enum_specifier":
return(CreateEnumSpecifier(first));
case "type_id":
return(CreateTypeId(first));
default:
return
(UnifiedType.Create(
UnifiedVariableIdentifier.Create(first.Value)));
}
}
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 UnifiedElement VisitPrimitiveType(
PrimitiveType primitiveType, object data)
{
return(UnifiedType.Create(primitiveType.Keyword));
}
