Esempio n. 1
0
 public ConstantExpression(Parser yyp, Constant c)
     : base(((LSLSyntax
         )yyp))
 {
     kids.Add(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; // TODO: This will probably break things
     }
 }
Esempio n. 3
0
        /// <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)
        {
            string retstr = String.Empty;

            // 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_float" == 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_float(" + c.Value + ")";
            }
            else if ("lsl_integer" == c.Type)
            {
                c.Value = "new lsl_integer(" + c.Value + ")";
            }
            else if ("lsl_string" == c.Type)
            {
                c.Value = "new lsl_string(\"" + c.Value + "\")";
            }

            retstr += Generate(c.Value, c);

            return retstr;
        }