示例#1
0
        public static UnifiedVariableDefinitionList CreateStructDeclaration(
            XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "struct_declaration");

            /*
             * struct_declaration
             * : specifier_qualifier_list struct_declarator_list ';'
             */

            var modifiersAndType = CreateSpecifierQualifierList(
                node.Element("specifier_qualifier_list"));
            var modifiers = modifiersAndType.Item1;
            var type      = modifiersAndType.Item2;

            var structDeclaratorList = node.Element("struct_declarator_list");
            UnifiedVariableDefinitionList variables = null;

            if (structDeclaratorList != null)
            {
                variables = UnifiedVariableDefinitionList.Create(
                    CreateStructDeclaratorList(structDeclaratorList).
                    Select(
                        e =>
                        UnifiedVariableDefinition.Create(
                            null, modifiers, type, e.Item1,
                            e.Item2)));
            }
            return(variables);
        }
 /// <summary>
 ///   変数のアクセス修飾子を付け替えます(UnifiedVariableDefinition オブジェクトの,Modifires プロパティを書き換えます)
 /// </summary>
 /// <param name="variable"> 対象の変数 </param>
 /// <param name="newModifierStrings"> 付け替えるアクセス修飾子 </param>
 public static void ChangeModifier(
     UnifiedVariableDefinition variable,
     params string[] newModifierStrings)
 {
     // TODO: Clear() するとアクセス修飾子以外(e.g. static) なども消えてしまうので,ignoredKeywordList とかどこかに用意して対処する
     variable.Modifiers.Clear();
     variable.Modifiers = UnifiedModifierCollection.Create(
             newModifierStrings.Select(UnifiedModifier.Create));
 }
示例#3
0
        public static UnifiedExpression CreateDeclaration(XElement node)
        {
            // TODO なぜかここのcontractにひっかかる
            //			Contract.Requires(node != null);
            //			Contract.Requires(node.Name() == "declaration");

            /*
             * declaration
             * :	'typedef' declaration_specifiers? {$declaration::isTypedef=true;}
             *      init_declarator_list ';' // special case, looking for typedef
             | declaration_specifiers init_declarator_list? ';'
             */

            var firstNode = node.FirstElement();

            switch (firstNode.Name())
            {
            case "TOKEN":
                // TODO このケースになるプログラムが未検証
                // typedef int S8; はいいけれど、これに初期化子も付けられるのが謎
                throw new NotImplementedException();
                break;

            // TODO プロトタイプ宣言はどう扱うか決める
            case "declaration_specifiers":
                // const int a = 0;
                // struct data { int x; }; => ここもこれになるのだけど、扱いはどうすれば
                var modifiersAndType = CreateDeclarationSpecifiers(firstNode);
                var modifiers        = modifiersAndType.Item1;
                var type             = modifiersAndType.Item2;     // TODO 返り値をtypeじゃなくす

                var initDeclaratorList = node.Element("init_declarator_list");
                if (initDeclaratorList == null)
                {
                    return(type.DeepCopy());
                }
                else
                {
                    UnifiedVariableDefinitionList variables = null;
                    variables = UnifiedVariableDefinitionList.Create(
                        CreateInitDeclaratorList(initDeclaratorList).
                        Select(
                            e =>
                            UnifiedVariableDefinition.Create(
                                null,
                                modifiers.DeepCopy(),
                                (UnifiedType)type.DeepCopy(),
                                e.Item1, e.Item2)));
                    return(variables);
                }

            default:
                throw new InvalidOperationException();
            }
        }
        // src と dst の衝突を調べて,衝突していれば src を,そうでなければ null を返す
        private static Boolean IsVariableCollision(UnifiedVariableDefinition src, UnifiedVariableDefinition dst)
        {
            var judges = new List<Boolean>();
            judges.Add(src.Name.Name == dst.Name.Name);

            if (judges.All(e => e))
            {
                return true;
            }
            return false;
        }
示例#5
0
        public UnifiedElement VisitEnumMemberDeclaration(
            EnumMemberDeclaration dec, object data)
        {
            var attrs = dec.Attributes.AcceptVisitorAsAttrs(this, data);
            var mods  = LookupModifiers(dec.Modifiers);
            var name  = UnifiedIdentifier.CreateVariable(dec.Name);
            var value = dec.Initializer.TryAcceptForExpression(this);

            return(UnifiedVariableDefinition.Create(
                       attrs, mods, /*no type*/ null, name, value,
                       /*no args*/ null, /*no bit field*/ null, /*no body*/ null));
        }
示例#6
0
        public UnifiedElement VisitForeachStatement(
            ForeachStatement stmt, object data)
        {
            var type = LookupType(stmt.VariableType);
            var name = stmt.VariableName.ToVariableIdentifier();
            var set  = stmt.InExpression.TryAcceptForExpression(this);
            var body =
                stmt.EmbeddedStatement.TryAcceptForExpression(this).ToBlock();

            var varDec = UnifiedVariableDefinition.Create(
                type: type, name: name);

            return(UnifiedForeach.Create(
                       varDec.ToVariableDefinitionList(), set, body));
        }
示例#7
0
 public override bool Visit(
     UnifiedVariableDefinition element, VisitorArgument arg)
 {
     element.Annotations.TryAccept(this, arg);
     element.Modifiers.TryAccept(this, arg);
     Writer.Write(" ");
     element.Type.TryAccept(this, arg);
     Writer.Write(" ");
     element.Name.TryAccept(this, arg);
     if (element.InitialValue != null)
     {
         Writer.Write(" = ");
         element.InitialValue.TryAccept(this, arg.Set(Brace));
     }
     element.Arguments.TryAccept(this, arg.Set(Paren));
     element.Body.TryAccept(this, arg);
     return(false);
 }
 public override bool Visit(
     UnifiedVariableDefinition element, VisitorArgument arg)
 {
     //for文の場合'var'は1つしか記述できないため、UnifiedVariableDefinitionListで'var'を出力済み
     if (arg.Decoration.Delimiter != ", ")
     {
         Writer.Write("var ");
     }
     element.Name.TryAccept(this, arg);
     if (element.InitialValue != null)
     {
         Writer.Write(" = ");
         element.InitialValue.TryAccept(this, arg.Set(Brace));
     }
     element.Arguments.TryAccept(this, arg.Set(Paren));
     element.Body.TryAccept(this, arg.Set(ForBlock));
     return(false);
 }
示例#9
0
        public UnifiedElement VisitVariableDeclarationStatement(
            VariableDeclarationStatement dec, object data)
        {
            var uMods     = LookupModifiers(dec.Modifiers);
            var uType     = LookupType(dec.Type);
            var variables =
                from nVar in dec.Variables
                let name = nVar.Name
                           let nInitValue = nVar.Initializer
                                            let uInitValue = nInitValue.TryAcceptForExpression(this)
                                                             select UnifiedVariableDefinition.Create(
                    /* no attribute */ null,
                    uMods.DeepCopy(),
                    uType.DeepCopy(),
                    name.ToVariableIdentifier(),
                    uInitValue);

            return(variables.ToVariableDefinitionList());
        }
示例#10
0
        public UnifiedElement VisitFieldDeclaration(
            FieldDeclaration dec, object data)
        {
            var attrs       = dec.Attributes.AcceptVisitorAsAttrs(this, data);
            var type        = LookupType(dec.ReturnType);
            var mods        = LookupModifiers(dec.Modifiers);
            var definitions =
                from nVar in dec.Variables
                let name = nVar.Name
                           let nInitValue = nVar.Initializer
                                            let uInitValue = nInitValue.TryAcceptForExpression(this)
                                                             select UnifiedVariableDefinition.Create(
                    attrs.DeepCopy(),
                    mods.DeepCopy(),
                    type.DeepCopy(),
                    name.ToVariableIdentifier(),
                    uInitValue);

            return(definitions.ToVariableDefinitionList());
        }
        // Javaにおけるリスト要素の削除を作成する例
        public static UnifiedBlock GenerateRemovingProcedureForList(
            UnifiedVariableDefinition list)
        {
            var name = list.Name;

            var property = UnifiedProperty.Create(
                    ".",
                    name.DeepCopy(),
                    UnifiedIdentifier.CreateLabel("remove"));
            var call = UnifiedCall.Create();
            call.Function = property;

            var argument =
                    UnifiedArgument.Create(UnifiedIdentifier.CreateLabel("i"));
            var arguments = UnifiedArgumentCollection.Create(argument);
            call.Arguments = arguments;

            var block = UnifiedBlock.Create();
            block.Add(call);

            return block;
        }
示例#12
0
        public static UnifiedVariableDefinition CreateEnumerator(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "enumerator");

            /*
             * enumerator
             * : IDENTIFIER ('=' constant_expression)?
             */

            var identifier =
                UnifiedIdentifier.CreateVariable(node.NthElement(0).Value);
            UnifiedExpression value = null;
            var expression          = node.Element("constant_expression");

            if (expression != null)
            {
                value = CreateConstantExpression(expression);
            }
            return(UnifiedVariableDefinition.Create(
                       null, null, null, identifier, value));
        }
        /// <summary>
        ///   フィールドからそれに対応するゲッタ(UnifiedFunctionDefinition オブジェクト)を生成します
        /// </summary>
        /// <param name="variable"> 対象の変数 </param>
        /// <param name="accessModifierString"> ゲッタのアクセス修飾子(デフォルトは public ) </param>
        /// <returns> 生成されたゲッタ(UnifiedFunctionDefinition オブジェクト) </returns>
        public static UnifiedFunctionDefinition GenerateGetter(
            UnifiedVariableDefinition variable,
            string accessModifierString = "public")
        {
            var getter = UnifiedFunctionDefinition.Create();
            var getterName = "get"
                             + StringUtil.UpperFirstChar(variable.Name.Name);
            getter.Name = UnifiedIdentifier.CreateLabel(getterName);
            getter.Type = variable.Type.DeepCopy();
            getter.Modifiers =
                    UnifiedModifierCollection.Create(
                            UnifiedModifier.Create(accessModifierString));

            getter.Parameters = UnifiedParameterCollection.Create(
                    UnifiedParameter.Create());

            var returnValue =
                    UnifiedIdentifier.CreateVariable(variable.Name.Name);
            var returnStatemenet = UnifiedReturn.Create(returnValue);
            var block = UnifiedBlock.Create(returnStatemenet);
            getter.Body = block;

            return getter;
        }
 public override bool Visit(
         UnifiedVariableDefinition element, VisitorArgument arg)
 {
     // UnifiedVariableDefinitionListで処理するので呼ばれてはいけない
     throw new InvalidOperationException();
 }
        /// <summary>
        ///   コレクションのコピーを返すメソッドを生成します
        /// </summary>
        /// <param name="variable"> 対象のコレクション </param>
        /// <param name="getterName"> 生成するメソッドの名前 </param>
        public static UnifiedFunctionDefinition GenerateClonedFieldGetter(
            UnifiedVariableDefinition variable,
            string getterName = "getCollection")
        {
            var func = UnifiedFunctionDefinition.Create();
            func.Name = UnifiedIdentifier.CreateLabel(getterName);
            func.Modifiers =
                    UnifiedModifierCollection.Create(
                            UnifiedModifier.Create("public"));
            func.Type = UnifiedType.Create("void");
            func.Parameters =
                    UnifiedParameterCollection.Create(UnifiedParameter.Create());

            var body = UnifiedBlock.Create();
            var returnStmt = UnifiedReturn.Create();
            returnStmt.Value = GenerateClonedField(variable);
            body.Add(returnStmt);

            func.Body = body;

            return func;
        }
示例#16
0
        public static Namespace GetNamespace(
            UnifiedVariableDefinition variableNode)
        {
            var type = NamespaceType.Variable;
            var variableName = variableNode.Name.Name;
            var parents =
                    DetectorHelper.GetParentTypes(type).Select(
                            t => DetectorHelper.Namespace2UnifiedType(t));
            var parentNode = DetectorHelper.GetFirstFoundNode(
                    variableNode, parents);

            return new Namespace {
                    Value = variableName,
                    NamespaceType = type,
                    Parent = Dispatcher(parentNode),
            };
        }
        /// <summary>
        ///   フィールドからそれに対応するセッタ(UnifiedFunctionDefinition オブジェクト)を生成します
        /// </summary>
        /// <param name="variable"> 対象の変数 </param>
        /// <param name="accessModifierString"> セッタのアクセス修飾子(デフォルトは public ) </param>
        /// <returns> 生成されたセッタ(UnifiedFunctionDefinition オブジェクト) </returns>
        public static UnifiedFunctionDefinition GenerateSetter(
            UnifiedVariableDefinition variable,
            string accessModifierString = "public")
        {
            var setter = UnifiedFunctionDefinition.Create();
            setter.Name = UnifiedIdentifier.CreateLabel(
                    "set" + StringUtil.UpperFirstChar(variable.Name.Name));
            setter.Type = UnifiedType.Create("void");

            var modifier = UnifiedModifier.Create(accessModifierString);
            setter.Modifiers = UnifiedModifierCollection.Create(modifier);

            var parameter = UnifiedParameter.Create(
                    null,
                    null,
                    variable.Type.DeepCopy(),
                    UnifiedIdentifierCollection.Create(variable.Name.DeepCopy())
                    );
            setter.Parameters = UnifiedParameterCollection.Create(parameter);

            var assignStatement = UnifiedBinaryExpression.Create(
                    UnifiedProperty.Create(
                            ".",
                            UnifiedIdentifier.CreateThis("this"),
                            variable.Name.DeepCopy()
                            ),
                    UnifiedBinaryOperator.Create(
                            "=", UnifiedBinaryOperatorKind.Assign),
                    parameter.Names.First().DeepCopy()
                    );

            var block = UnifiedBlock.Create(assignStatement);
            setter.Body = block;

            return setter;
        }
 public override bool Visit(
         UnifiedVariableDefinition element, VisitorArgument arg)
 {
     //for文の場合'var'は1つしか記述できないため、UnifiedVariableDefinitionListで'var'を出力済み
     if (arg.Decoration.Delimiter != ", ") {
         Writer.Write("var ");
     }
     element.Name.TryAccept(this, arg);
     if (element.InitialValue != null) {
         Writer.Write(" = ");
         element.InitialValue.TryAccept(this, arg.Set(Brace));
     }
     element.Arguments.TryAccept(this, arg.Set(Paren));
     element.Body.TryAccept(this, arg.Set(ForBlock));
     return false;
 }
 public override bool Visit(
         UnifiedVariableDefinition element, VisitorArgument arg)
 {
     element.Annotations.TryAccept(this, arg);
     element.Modifiers.TryAccept(this, arg);
     Writer.Write(" ");
     element.Type.TryAccept(this, arg);
     Writer.Write(" ");
     element.Name.TryAccept(this, arg);
     if (element.InitialValue != null) {
         Writer.Write(" = ");
         element.InitialValue.TryAccept(this, arg.Set(Brace));
     }
     element.Arguments.TryAccept(this, arg.Set(Paren));
     element.Body.TryAccept(this, arg);
     return false;
 }
        /// <summary>
        ///   入力されたフィールドをクローンしたフィールドを表すモデルを生成します
        /// </summary>
        /// <param name="variable"> クローン対象の(コレクション)フィールド </param>
        /// <param name="cloningMethodName"> クローンに利用するメソッドの名前を指定します </param>
        /// <returns> </returns>
        public static UnifiedCall GenerateClonedField(
            UnifiedVariableDefinition variable,
            string cloningMethodName = "clone")
        {
            // TODO 上2つと同じように,クローン方法を任意に与えられるようにする?
            var clonedField = UnifiedProperty.Create(
                    ".",
                    variable.Name.DeepCopy(),
                    UnifiedIdentifier.CreateLabel(cloningMethodName)
                    );
            var cloned = UnifiedCall.Create(
                    clonedField,
                    UnifiedArgumentCollection.Create(
                            UnifiedArgument.Create(null)));

            return cloned;
        }
 public override bool Visit(
     UnifiedVariableDefinition element, VisitorArgument arg)
 {
     // UnifiedVariableDefinitionListで処理するので呼ばれてはいけない
     throw new InvalidOperationException();
 }