예제 #1
0
        /**
         * Executed after all other tokens are added. Literal tokens are
         * segmented from the original source code, separated by the ranges
         * of the other tokens.
         */
        internal static void AddLiteralTokens(string literal, List <MetaToken> tokens)
        {
            for (int i = 0, size = tokens.Count; i <= size; ++i)
            {
                int startIndex;
                int length = 0;

                if (i == 0)
                {
                    startIndex = 0;
                }
                else
                {
                    startIndex = tokens[i - 1].startIndex + tokens[i - 1].length;
                }

                if (i < size)
                {
                    length = tokens[i].startIndex - startIndex;
                }
                else
                {
                    length = literal.Length - startIndex;
                }

                if (length > 0)
                {
                    tokens.Add(MetaToken.LITERAL(literal, startIndex, length));
                }
            }

            tokens.SortAndReduce();
        }
예제 #2
0
파일: VM.cs 프로젝트: d3m0n5/GDB
        private string META_GetListSize(MetaToken listvar)
        {
            var list_prefix = LISTVAR_GetListName(listvar.text[0]);
            var list_var    = META_GetList(list_prefix);

            return("(" + list_var + ")->size()");
        }
예제 #3
0
파일: MetaToken.cs 프로젝트: d3m0n5/GDB
 internal static void SortAndReduce(this List <MetaToken> tokens)
 {
     tokens.Sort((a, b) =>
     {
         var ret = a.startIndex - b.startIndex;
         if (ret == 0)
         {
             ret = a.length - b.length;
             if (ret == 0)
             {
                 if (a.type != b.type)
                 {
                     Console.WriteLine(a.ToString());
                     Console.WriteLine(b.ToString());
                     MetaToken.Throw("Different tokens with same range");
                 }
             }
         }
         return(ret);
     });
     for (int i = 1; i < tokens.Count; ++i)
     {
         if (tokens[i - 1].startIndex + tokens[i - 1].length >= tokens[i].startIndex + tokens[i].length)
         {
             tokens.RemoveAt(i);
             --i;
         }
     }
 }
예제 #4
0
파일: MetaToken.cs 프로젝트: d3m0n5/GDB
        public static MetaToken GeneralFactory(string text, int startIdx, int len, string type_str, int param_count)
        {
            var meta = new MetaToken();
            var type = (MetaType)Enum.Parse(typeof(MetaType), type_str);

            meta.original_text = text;
            try
            {
                meta.startIndex = startIdx;
                meta.length     = len;
                meta.type       = type;
                meta.text       = CaptureArguments(text, startIdx, len);

                CheckParamCount(meta.text, param_count, type_str);
            }
            catch (Exception e)
            {
                Console.WriteLine("Current token:");
                Console.WriteLine(meta);
                Console.WriteLine("Text:");
                Console.WriteLine(text.Substring(startIdx, len));

                throw;
            }

            return(meta);
        }
예제 #5
0
파일: VM.cs 프로젝트: d3m0n5/GDB
        private void META_SetListDepth(MetaToken listvar)
        {
            //XXX currently nested iteration over a same list is impossible,
            //as we only have a flat dict string->int for the iteration depth,
            //and inner depth will overwrite the outer one.
            var list_prefix = LISTVAR_GetListName(listvar.text[0]);

            d_list_iterator_depth[list_prefix] = state.foreach_depth;
        }
예제 #6
0
파일: MetaToken.cs 프로젝트: d3m0n5/GDB
        public static MetaToken END(string text, int startIdx, int len)
        {
            var meta = new MetaToken();

            meta.startIndex    = startIdx;
            meta.length        = len;
            meta.type          = MetaType.END;
            meta.original_text = text;

            return(meta);
        }
예제 #7
0
파일: MetaToken.cs 프로젝트: d3m0n5/GDB
        public static MetaToken TEMPLATE(string text, int startIdx, int len)
        {
            var meta = new MetaToken();

            meta.startIndex    = startIdx;
            meta.length        = len;
            meta.type          = MetaType.TEMPLATE;
            meta.original_text = text;
            meta.text.Add(text.Substring(startIdx, len));

            return(meta);
        }
예제 #8
0
파일: VM.cs 프로젝트: d3m0n5/GDB
        private bool Is_LISTVAR(MetaToken i)
        {
            if (i.type == MetaType.USE_LIST)
            {
                return(true);
            }
            if (i.type != MetaType.TEMPLATE)
            {
                return(false);
            }
            var template_name = i.text[0];

            if (null != LISTVAR_GetListName(template_name))
            {
                return(true);
            }
            return(false);
        }
예제 #9
0
파일: MetaToken.cs 프로젝트: d3m0n5/GDB
        internal static void InsertFromRegex(this List <MetaToken> tokens, string literal, Expression <Func <Regex> > rgx_func)
        {
            var rgx      = rgx_func.Compile()();
            var rgx_name = rgx_func.ToString();
            int idx      = rgx_name.LastIndexOf('.') + 1;
            int len      = rgx_name.Length - idx;

            rgx_name = rgx_name.Substring(idx, len);

            foreach (var attr in typeof(MetaType).GetMember(rgx_name)[0].GetCustomAttributes(false))
            {
                var param_attr = (PARAMAttribute)attr;
                if (param_attr != null)
                {
                    tokens.AddRange(from Match m in rgx.Matches(literal) select MetaToken.GeneralFactory(literal, m.Index, m.Length, rgx_name, param_attr.param_count));
                    return;
                }
            }

            var meta_gen = typeof(MetaToken).GetMethod(rgx_name).CreateDelegate(typeof(META_TOKEN_GEN_FUNC)) as META_TOKEN_GEN_FUNC;

            tokens.AddRange(from Match m in rgx.Matches(literal) select meta_gen(literal, m.Index, m.Length));
        }