Beispiel #1
0
        public Define(string s, bool autoAssume)
        {
            //string firstPart = s.Substring(0, s.IndexOf("$") + 1);  // int&a,b
            //while (s.IndexOf(',') > 0)
            //{
            //    int at = s.IndexOf(',');
            //    s = s.Substring(0, s.IndexOf(',')) + ';' + firstPart + s.Substring(s.IndexOf(',') + 1);
            //    //
            //}

            string[] ss = s.Split('$');
            //string varName;
            VT   varType;
            bool everDefined = false;

            for (int i = 0; i < ASTTree.variables.Count; i++)
            {
                if (ASTTree.variables[i].name == ss[1] && MISC.isVariableAvailable(i))
                {
                    everDefined = true; break;
                }
            }

            if (ss[1].Length > 0 && !everDefined)
            {
                varName = ss[1];
            }
            else
            {
                throw new Exception("Can not define " + ((everDefined) ? "again " : "") + "variable with name \"" + ss[1] + "\"");
            }

            ss[0].ToLower();
            varType = detectType(ss[0]);

            //for (int i =0; i < varName.Length; i++){
            //bool isPointer = false;
            int pointerLevel = 0;

            while (varName.IndexOf('*') == 0)
            {
                pointerLevel++; varName = varName.Substring(1);
            }
            returnType = new ValueType(varType, pointerLevel);
            defineType = returnType;

            //____________________________________

            if (varName.LastIndexOf("]") == varName.Length - 1 && varName.IndexOf("[") > 0)
            {
                List <string> inBr = MISC.splitByQuad(varName);  // [] [] [ ] []
                varName = varName.Substring(0, varName.IndexOf('['));

                for (int ib = 0; ib < inBr.Count; ib++)
                {
                    string inBrack = inBr[ib];
                    int    length  = 0;
                    if (inBrack != "")
                    {
                        IOperation arrayLength = BinaryOperation.ParseFrom(inBrack);
                        if (arrayLength.returnTypes() != VT.Cint)
                        {
                            throw new Exception("Int only can be array length parameter");
                        }
                        //IOperation arrayLength = BinaryOperation.ParseFrom(inBrack);
                        //if (arrayLength as ASTvalue == null || arrayLength.returnTypes() != VT.Cint)
                        //    throw new Exception("Incorrect array length parameters!");

                        //length = (int)(arrayLength as ASTvalue).getValue;
                        //if (length < 1)
                        //    throw new Exception("Array length should be 1 and more!");
                    }

                    //for (int i = 0; i < length; i++)
                    //{
                    //    // as default variable
                    //    ASTvariable newVar = new ASTvariable(new ValueType(varType, pointerLevel), varName + "#" + i, 0);
                    //    ASTTree.variables.Add(newVar);
                    //    MISC.pushVariable(ASTTree.variables.Count - 1);
                    //    ASTTree.tokens.Add(newVar);
                    //}
                    defineType = defineType.TypeOfPointerToThis();
                }
            }
            //_________________________________________

            ASTvariable NV = new ASTvariable(defineType, varName, pointerLevel, MISC.GetCurrentVariableAdressType());

            var = NV;
            ASTTree.variables.Add(NV);
            MISC.pushVariable(ASTTree.variables.Count - 1);
            if (autoAssume)
            {
                MISC.defineVariable(ASTTree.variables.Count - 1);
            }

            ASTTree.tokens.Add(NV);
            a = NV;

            returnType = a.returnTypes();

            b = new ASTvalue(new ValueType(VT.Cadress), (object)(ASTTree.variables.Count - 1));
        }
Beispiel #2
0
        public static IOperation ParseFrom(string s)
        {
            if (s.IndexOf('{') == 0 && s.LastIndexOf('}') == s.Length - 1)
            {
                return(new StructureDefine(MISC.getIn(s, 0)));
            }
            if (s.IndexOf('(') == 0 && s.LastIndexOf(')') == s.Length - 1)
            {
                return(BinaryOperation.ParseFrom(MISC.breakBrackets(s)));
            }


            if (s.Length > 2 && s.IndexOf("--") == s.Length - 2)
            {
                IOperation lt = ParseFrom(s.Substring(0, s.Length - 2));
                return(new Assum(lt, new Diff(lt, new ASTvalue(new ValueType(VT.Cint), (object)1))));
                //return new Dscr());
            }

            if (s.Length > 2 && s.IndexOf("++") == s.Length - 2)
            {
                //return new Incr(ParseFrom(s.Substring(0, s.Length - 2)));
                IOperation lt = ParseFrom(s.Substring(0, s.Length - 2));
                return(new Assum(lt, new Summ(lt, new ASTvalue(new ValueType(VT.Cint), (object)1))));
            }

            if (s.IndexOf("-") == 0)
            {
                return(new Mins(ParseFrom(s.Substring(1, s.Length - 1))));
            }

            if (s.IndexOf("!") == 0)
            {
                return(new Nega(ParseFrom(s.Substring(1, s.Length - 1))));
            }

            if (s.IndexOf("&") == 0)
            {
                callDefined = true; ///!
                IOperation gettingAdressOf = ParseFrom(s.Substring(1, s.Length - 1));
                return(new Adrs(gettingAdressOf));
            }



            int varType = Math.Max((s.IndexOf("int") == 0) ? 2 : -1, Math.Max((s.IndexOf("double") == 0) ? 5 : -1, Math.Max((s.IndexOf("char") == 0) ? 3 : -1,
                                                                                                                            Math.Max((s.IndexOf("string") == 0) ? 5 : -1, (s.IndexOf("bool") == 0) ? 3 : -1))));

            if (varType >= 0)
            {
                s = s.Insert(varType + 1, "$");
                return(new Define(s, false));
            }

            if (s.IndexOf("*") == 0)
            {
                IOperation pointTo = ParseFrom(s.Substring(1, s.Length - 1));
                return(new GetValByAdress(pointTo, (pointTo).returnTypes()));

                throw new Exception("Invalid pointer selected!");
            }
            try
            {
                return(new ASTFunctionCall(s));
            }
            catch (Exception e)
            {
                if (e.Message.IndexOf("is not a function") < 0)
                {
                    throw new Exception(e.Message);
                }
            }
            if (s.LastIndexOf("]") == s.Length - 1 && s.IndexOf("[") > 0)
            {
                //IOperation pointTo = ;
                //return
                //    new GetValByAdress(new Summ(pointTo,
                //        BinaryOperation.ParseFrom(MISC.getIn(s, s.IndexOf('[')))),
                //        (pointTo).returnTypes());
                //throw new Exception("Invalid pointer selected!");
                callDefined = true; ///!

                string        sContainBrackets = s.Substring(s.IndexOf("["));
                List <string> getedBrs         = MISC.splitByQuad(sContainBrackets);

                IOperation resOper = ParseFrom(s.Substring(0, s.IndexOf('[')));

                for (int o = 0; o < getedBrs.Count; o++)
                {
                    IOperation currentBrsOp = BinaryOperation.ParseFrom(getedBrs[o]);
                    resOper = new GetValByAdress(new Summ(resOper, currentBrsOp), resOper.returnTypes());
                }
                return(resOper);
            }
            //f (s.IndexOf('(') == 0 && s.LastIndexOf(')') == s.Length - 1)
            //return ParseFrom(MISC.breakBrackets(s));



            try
            {
                ASTvalue res = new ASTvalue(s, callDefined);
                callDefined = false;
                return(res);
            }
            catch (Exception e)
            {
                callDefined = false;
                if (e.Message.IndexOf("GetAddr") == 0)
                {
                    int newAdress = int.Parse(e.Message.Split('_')[1]);
                    return(new GetValByAdress(new ASTvalue(new ValueType(VT.Cadress), (object)newAdress),
                                              ASTTree.variables[newAdress].getValueType));
                }
                throw new Exception(e.Message);
            }
            //finally
            //{
            //    calldefined = false;
            //}
        }