Inheritance: Tools.SYMBOL
        /// <summary>
        ///     Generates the code for a Constant node.
        /// </summary>
        /// <param name="c">The Constant node.</param>
        /// <returns>String containing C# code for Constant c.</returns>
        private string GenerateConstant(Constant c)
        {
            // Supprt LSL's weird acceptance of floats with no trailing digits
            // after the period. Turn float x = 10.; into float x = 10.0;
            if ("LSL_Types.LSLFloat" == c.Type)
            {
                int dotIndex = c.Value.IndexOf('.') + 1;
                if (0 < dotIndex && (dotIndex == c.Value.Length || !Char.IsDigit(c.Value[dotIndex])))
                    c.Value = c.Value.Insert(dotIndex, "0");
                c.Value = "new LSL_Types.LSLFloat(" + c.Value + ")";
            }
            else if ("LSL_Types.LSLInteger" == c.Type)
            {
                c.Value = "new LSL_Types.LSLInteger(" + c.Value + ")";
            }
            else if ("LSL_Types.LSLString" == c.Type)
            {
                c.Value = "new LSL_Types.LSLString(\"" + c.Value + "\")";
            }

            return Generate(c.Value, c);
        }
 /// <summary>
 ///     Generates the node structure required to generate a default
 ///     initialization.
 /// </summary>
 /// <param name="p">
 ///     Tools.Parser instance to use when instantiating nodes.
 /// </param>
 /// <param name="constantType">String describing the datatype.</param>
 /// <returns>
 ///     A SYMBOL node conaining the appropriate structure for intializing a
 ///     constantType.
 /// </returns>
 private SYMBOL GetZeroConstant(Parser p, string constantType)
 {
     switch (constantType)
     {
         case "integer":
             return new Constant(p, constantType, "0");
         case "float":
             return new Constant(p, constantType, "0.0");
         case "string":
         case "key":
             return new Constant(p, constantType, "");
         case "list":
             ArgumentList al = new ArgumentList(p);
             return new ListConstant(p, al);
         case "vector":
             Constant vca = new Constant(p, "float", "0.0");
             Constant vcb = new Constant(p, "float", "0.0");
             Constant vcc = new Constant(p, "float", "0.0");
             ConstantExpression vcea = new ConstantExpression(p, vca);
             ConstantExpression vceb = new ConstantExpression(p, vcb);
             ConstantExpression vcec = new ConstantExpression(p, vcc);
             return new VectorConstant(p, vcea, vceb, vcec);
         case "rotation":
             Constant rca = new Constant(p, "float", "0.0");
             Constant rcb = new Constant(p, "float", "0.0");
             Constant rcc = new Constant(p, "float", "0.0");
             Constant rcd = new Constant(p, "float", "0.0");
             ConstantExpression rcea = new ConstantExpression(p, rca);
             ConstantExpression rceb = new ConstantExpression(p, rcb);
             ConstantExpression rcec = new ConstantExpression(p, rcc);
             ConstantExpression rced = new ConstantExpression(p, rcd);
             return new RotationConstant(p, rcea, rceb, rcec, rced);
         default:
             return null; // this will probably break stuff
     }
 }
        private string GetValue(Constant identEx)
        {
            if (identEx == null) return null;
            if (identEx.Value != null)
                return identEx.Value;
            StringBuilder retVal = new StringBuilder();
            if (identEx is VectorConstant)
            {
                VectorConstant vc = (VectorConstant) identEx;

                retVal.Append(Generate(String.Format("new {0}(", vc.Type), vc));
                retVal.Append(GenerateNode((SYMBOL) vc.kids[0]));
                retVal.Append(Generate(", "));
                retVal.Append(GenerateNode((SYMBOL) vc.kids[1]));
                retVal.Append(Generate(", "));
                retVal.Append(GenerateNode((SYMBOL) vc.kids[2]));
                retVal.Append(Generate(")"));

                return retVal.ToString();
            }
            if (identEx is RotationConstant)
            {
                RotationConstant rc = (RotationConstant) identEx;

                retVal.Append(Generate(String.Format("new {0}(", rc.Type), rc));
                retVal.Append(GenerateNode((SYMBOL) rc.kids[0]));
                retVal.Append(Generate(", "));
                retVal.Append(GenerateNode((SYMBOL) rc.kids[1]));
                retVal.Append(Generate(", "));
                retVal.Append(GenerateNode((SYMBOL) rc.kids[2]));
                retVal.Append(Generate(", "));
                retVal.Append(GenerateNode((SYMBOL) rc.kids[3]));
                retVal.Append(Generate(")"));

                return retVal.ToString();
            }
            if (identEx is ListConstant)
                return GenerateListConstant((ListConstant) identEx);
            return null;
        }
示例#4
0
 public ConstantExpression(Parser yyp, Constant c) : base((yyp))
 {
     kids.Add(c);
 }