Ejemplo n.º 1
0
        public override CSNode VisitType(CSScriptParser.TypeContext context)
        {
            System.Type currentType;
            string      currentTypeString = VisitTypeElements(context.type_elements(), out currentType);

            if (context.arraytype() != null)
            {
                currentType = ReflectionUtil.GetType(currentTypeString + "[]");
            }

            if (currentType == null)
            {
                CSLog.E(context.Start.Line, context.Start.Column, "unknown type: " + currentTypeString);
                return(null);
            }

            CSTypeNode node = new CSTypeNode(context.Start.Line, context.Start.Column);

            node._type         = currentType;
            node._typeString   = currentType.AssemblyQualifiedName;
            node._assemblyName = currentType.Assembly.GetCleanName();
            //CSLog.D ("full name: " + node._typeString + " in the assembly: " + node._assemblyName);

            return(node);
        }
Ejemplo n.º 2
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);
        }
Ejemplo n.º 3
0
        public override CSNode VisitVarDeclExp(CSScriptParser.VarDeclExpContext context)
        {
            CSLocalVariableNode variableNode = new CSLocalVariableNode(context.Start.Line, context.Start.Column);

            variableNode._declaration  = true;
            variableNode._variableName = context.NAME().GetText();

            CSScriptParser.TypeContext vartypes = context.type();
            if (vartypes != null)
            {
                CSTypeNode typeNode = Visit(vartypes) as CSTypeNode;
                if (typeNode == null)
                {
                    CSLog.E(variableNode, "failed to get the type");
                }
                variableNode._type = typeNode._type;
            }

            CSObject objForComplier = CSObject.LocalVariableObject(variableNode, variableNode._type, variableNode._variableName, null);

            _state.AddVariable(variableNode._variableName, objForComplier);

            return(variableNode);
        }
Ejemplo n.º 4
0
        CSNode VisitSelectors(CSScriptParser.SelectorContext[] selectors, int line, int col)
        {
            int selectorLen = selectors.Length;

            string firstName = selectors[0].NAME().GetText();

            if (_state.HasVariable(firstName))
            {
                CSLocalVariableNode node = new CSLocalVariableNode(line, col);
                node._declaration  = false;
                node._variableName = firstName;
                if (selectorLen == 1)
                {
                    return(node);
                }
                else
                {
                    CSSelectorNode selectorNode = new CSSelectorNode(line, col);
                    selectorNode._selectors = GetSelectorStrings(selectors, 1);
                    CSOPDotNode dotNode = new CSOPDotNode(line, col);
                    dotNode._children    = new CSNode[2];
                    dotNode._children[0] = node;
                    dotNode._children[1] = selectorNode;
                    return(dotNode);
                }
            }

            string currentTypeString = null;

            System.Type currentType = null;
            int         typeStart   = -1;
            int         typeEnd     = 0;

            for (int i = 0; i < selectorLen; ++i)
            {
                CSScriptParser.SelectorContext next = selectors[i];
                string name = next.NAME().GetText();
                currentTypeString = GetTypeString(selectors, i + 1, typeStart);
                System.Type nextType = ReflectionUtil.GetType(currentTypeString);

                if (typeStart == -1 && nextType != null)
                {
                    typeStart = i;
                }

                if (currentType != null && nextType == null)
                {
                    typeEnd = i;
                    break;
                }
                currentType = nextType;
            }

            if (currentType != null)
            {
                if (typeEnd == 0)
                {
                    CSTypeNode node = new CSTypeNode(line, col);
                    node._typeString   = currentTypeString;
                    node._type         = currentType;
                    node._assemblyName = currentType.Assembly.GetCleanName();
                    return(node);
                }
                else
                {
                    CSStaticVariableNode node = new CSStaticVariableNode(line, col);
                    string varName            = selectors[typeEnd].NAME().GetText();
                    node._variableName = varName;
                    node._staticType   = currentType;
                    node._type         = ReflectionUtil.GetFieldType(currentType, varName);

                    if (node._type == null)
                    {
                        CSLog.E(node, "type: " + currentType.FullName + " doesn't have: " + varName);
                    }

                    if (selectorLen == typeEnd + 1)
                    {
                        return(node);
                    }
                    else
                    {
                        CSSelectorNode selectorNode = new CSSelectorNode(line, col);
                        selectorNode._selectors = GetSelectorStrings(selectors, typeEnd + 1);
                        CSOPDotNode dotNode = new CSOPDotNode(line, col);
                        dotNode._children    = new CSNode[2];
                        dotNode._children[0] = node;
                        dotNode._children[1] = selectorNode;
                        return(dotNode);
                    }
                }
            }
            else
            {
                CSSelectorNode node = new CSSelectorNode(line, col);
                node._selectors = GetSelectorStrings(selectors, 0);
                return(node);
            }
        }
Ejemplo n.º 5
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);
        }
Ejemplo n.º 6
0
        public override CSNode VisitNewExp(CSScriptParser.NewExpContext context)
        {
            CSOPNewNode node = new CSOPNewNode(context.Start.Line, context.Start.Column);

            node._children = new CSNode[6];

            CSScriptParser.ParametersContext  parameters = context.parameters();
            CSScriptParser.Array_indexContext arrayIndex = context.array_index();

            System.Type currentType;
            string      currentTypeString = VisitTypeElements(context.type_elements(), out currentType);

            if (arrayIndex != null)
            {
                currentTypeString = currentTypeString + "[]";
                currentType       = ReflectionUtil.GetType(currentTypeString);
            }

            if (currentType == null)
            {
                CSLog.E(node, "unknown type: " + currentTypeString);
                return(null);
            }

            CSTypeNode typeNode = new CSTypeNode(context.Start.Line, context.Start.Column);

            typeNode._type         = currentType;
            typeNode._typeString   = currentTypeString;
            typeNode._assemblyName = currentType.Assembly.GetCleanName();

            node._children[0] = typeNode;

            if (parameters != null)
            {
                node._children[1] = Visit(parameters);
            }

            if (arrayIndex != null)
            {
                node._children[2] = Visit(arrayIndex);
            }

            CSScriptParser.InitializerContext initializer = context.initializer();
            if (initializer != null)
            {
                CSScriptParser.Array_initializerContext arrayInitializer = initializer.array_initializer();
                if (arrayInitializer != null)
                {
                    node._children[3] = Visit(arrayInitializer);
                }

                CSScriptParser.Dictionary_initializerContext dictionaryInitializer = initializer.dictionary_initializer();
                if (dictionaryInitializer != null)
                {
                    node._children[4] = Visit(dictionaryInitializer);
                }

                CSScriptParser.Class_initializerContext classInitializer = initializer.class_initializer();
                if (classInitializer != null)
                {
                    node._children[5] = Visit(classInitializer);
                }
            }
            return(node);
        }