示例#1
0
        CSTypeNode[] GetGenericParameters(CSScriptParser.Generic_parametersContext context)
        {
            CSScriptParser.TypeContext[] genericTypes = context.type();
            int tempVarCount = genericTypes.Length;

            CSTypeNode[] types = new CSTypeNode[tempVarCount];

            for (int i = 0; i < tempVarCount; ++i)
            {
                CSTypeNode child = VisitType(genericTypes[i]) as CSTypeNode;
                types[i] = child;
            }

            return(types);
        }
示例#2
0
        public override CSNode VisitFuncExp(CSScriptParser.FuncExpContext context)
        {
            CSFunctionNode node = new CSFunctionNode(context.Start.Line, context.Start.Column);

            node._functionName = context.NAME().GetText();
            node._children     = new CSNode[2];
            node._children[0]  = VisitSelectors(context.selector(), context.Start.Line, context.Start.Column);
            node._children[1]  = Visit(context.parameters());

            CSScriptParser.Generic_parametersContext generic = context.generic_parameters();
            if (generic != null)
            {
                node._genericParameters = GetGenericParameters(generic);
            }
            return(node);
        }
示例#3
0
        string _GetTypeString(
            object[] vartypes,
            int varCount,
            int typeStart,
            System.Func <object, string> getName,
            System.Func <object, CSScriptParser.Generic_parametersContext> getGenericParams)
        {
            System.Text.StringBuilder sb         = new System.Text.StringBuilder();
            System.Text.StringBuilder sbTemplate = new System.Text.StringBuilder();

            sbTemplate.Append('[');

            bool isThereTemplate = false;

            for (int i = 0; i < varCount; ++i)
            {
                object next = vartypes[i];
                if (i != 0)
                {
                    if (typeStart >= 0 && typeStart < i)
                    {
                        sb.Append('+');
                    }
                    else
                    {
                        sb.Append('.');
                    }
                }

                string name = getName(next);

                sb.Append(ReflectionUtil.GetCleanNameIfPrimitive(name));

                CSScriptParser.Generic_parametersContext genericParameters = getGenericParams(next);
                if (genericParameters != null)
                {
                    CSScriptParser.TypeContext[] genericTypes = genericParameters.type();
                    int tempVarCount = genericTypes.Length;
                    if (tempVarCount > 0)
                    {
                        if (isThereTemplate)
                        {
                            sbTemplate.Append(',');
                        }
                        else
                        {
                            isThereTemplate = true;
                        }

                        sb.Append('`');
                        sb.Append(tempVarCount.ToString());
                        sbTemplate.Append('[');
                        for (int j = 0; j < tempVarCount; ++j)
                        {
                            if (j != 0)
                            {
                                sbTemplate.Append("], [");
                            }
                            CSTypeNode child = VisitType(genericTypes[j]) as CSTypeNode;
                            sbTemplate.Append(child._typeString);
                        }
                        sbTemplate.Append(']');
                    }
                }
            }
            sbTemplate.Append(']');

            if (isThereTemplate)
            {
                sb.Append(sbTemplate.ToString());
            }

            string typeString = sb.ToString();

            return(typeString);
        }
 /// <summary>
 /// Visit a parse tree produced by <see cref="CSScriptParser.generic_parameters"/>.
 /// <para>
 /// The default implementation returns the result of calling <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
 /// on <paramref name="context"/>.
 /// </para>
 /// </summary>
 /// <param name="context">The parse tree.</param>
 /// <return>The visitor result.</return>
 public virtual Result VisitGeneric_parameters([NotNull] CSScriptParser.Generic_parametersContext context)
 {
     return(VisitChildren(context));
 }