196 lines
8.9 KiB
C#
196 lines
8.9 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using Tools;
|
|
|
|
namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
|
|
{
|
|
public class LSL2CSCodeTransformer
|
|
{
|
|
private SYMBOL m_astRoot = null;
|
|
private static Dictionary<string, string> m_datatypeLSL2OpenSim = null;
|
|
|
|
/// <summary>
|
|
/// Pass the new CodeTranformer an abstract syntax tree.
|
|
/// </summary>
|
|
/// <param name="astRoot">The root node of the AST.</param>
|
|
public LSL2CSCodeTransformer(SYMBOL astRoot)
|
|
{
|
|
m_astRoot = astRoot;
|
|
|
|
// let's populate the dictionary
|
|
if (null == m_datatypeLSL2OpenSim)
|
|
{
|
|
m_datatypeLSL2OpenSim = new Dictionary<string, string>();
|
|
m_datatypeLSL2OpenSim.Add("integer", "LSL_Types.LSLInteger");
|
|
m_datatypeLSL2OpenSim.Add("float", "LSL_Types.LSLFloat");
|
|
//m_datatypeLSL2OpenSim.Add("key", "LSL_Types.key"); // key doesn't seem to be used
|
|
m_datatypeLSL2OpenSim.Add("key", "LSL_Types.LSLString");
|
|
m_datatypeLSL2OpenSim.Add("string", "LSL_Types.LSLString");
|
|
m_datatypeLSL2OpenSim.Add("vector", "LSL_Types.Vector3");
|
|
m_datatypeLSL2OpenSim.Add("rotation", "LSL_Types.Quaternion");
|
|
m_datatypeLSL2OpenSim.Add("list", "LSL_Types.list");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Transform the code in the AST we have.
|
|
/// </summary>
|
|
/// <returns>The root node of the transformed AST</returns>
|
|
public SYMBOL Transform()
|
|
{
|
|
foreach (SYMBOL s in m_astRoot.kids)
|
|
TransformNode(s);
|
|
|
|
return m_astRoot;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recursively called to transform each type of node. Will transform this
|
|
/// node, then all it's children.
|
|
/// </summary>
|
|
/// <param name="s">The current node to transform.</param>
|
|
private void TransformNode(SYMBOL s)
|
|
{
|
|
// make sure to put type lower in the inheritance hierarchy first
|
|
// ie: since IdentConstant and StringConstant inherit from Constant,
|
|
// put IdentConstant and StringConstant before Constant
|
|
if (s is Declaration)
|
|
((Declaration) s).Datatype = m_datatypeLSL2OpenSim[((Declaration) s).Datatype];
|
|
else if (s is Constant)
|
|
((Constant) s).Type = m_datatypeLSL2OpenSim[((Constant) s).Type];
|
|
else if (s is TypecastExpression)
|
|
((TypecastExpression) s).TypecastType = m_datatypeLSL2OpenSim[((TypecastExpression) s).TypecastType];
|
|
else if (s is GlobalFunctionDefinition && "void" != ((GlobalFunctionDefinition) s).ReturnType) // we don't need to translate "void"
|
|
((GlobalFunctionDefinition) s).ReturnType = m_datatypeLSL2OpenSim[((GlobalFunctionDefinition) s).ReturnType];
|
|
|
|
for (int i = 0; i < s.kids.Count; i++)
|
|
{
|
|
// It's possible that a child is null, for instance when the
|
|
// assignment part in a for-loop is left out, ie:
|
|
//
|
|
// for (; i < 10; i++)
|
|
// {
|
|
// ...
|
|
// }
|
|
//
|
|
// We need to check for that here.
|
|
if (null != s.kids[i])
|
|
{
|
|
if (!(s is Assignment || s is ArgumentDeclarationList) && s.kids[i] is Declaration)
|
|
AddImplicitInitialization(s, i);
|
|
|
|
TransformNode((SYMBOL) s.kids[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces an instance of the node at s.kids[didx] with an assignment
|
|
/// node. The assignment node has the Declaration node on the left hand
|
|
/// side and a default initializer on the right hand side.
|
|
/// </summary>
|
|
/// <param name="s">
|
|
/// The node containing the Declaration node that needs replacing.
|
|
/// </param>
|
|
/// <param name="didx">Index of the Declaration node to replace.</param>
|
|
private void AddImplicitInitialization(SYMBOL s, int didx)
|
|
{
|
|
// We take the kids for a while to play with them.
|
|
int sKidSize = s.kids.Count;
|
|
object [] sKids = new object[sKidSize];
|
|
for (int i = 0; i < sKidSize; i++)
|
|
sKids[i] = s.kids.Pop();
|
|
|
|
// The child to be changed.
|
|
Declaration currentDeclaration = (Declaration) sKids[didx];
|
|
|
|
// We need an assignment node.
|
|
Assignment newAssignment = new Assignment(currentDeclaration.yyps,
|
|
currentDeclaration,
|
|
GetZeroConstant(currentDeclaration.yyps, currentDeclaration.Datatype),
|
|
"=");
|
|
sKids[didx] = newAssignment;
|
|
|
|
// Put the kids back where they belong.
|
|
for (int i = 0; i < sKidSize; i++)
|
|
s.kids.Add(sKids[i]);
|
|
}
|
|
|
|
/// <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
|
|
}
|
|
}
|
|
}
|
|
}
|