/// <summary>
/// Generates the code for a CompoundStatement node.
/// </summary>
/// <param name="cs">The CompoundStatement node.</param>
/// <returns>String containing C# code for CompoundStatement cs.</returns>
private void GenerateCompoundStatement(SYMBOL previousSymbol, CompoundStatement cs, StringBuilder sb)
{
// opening brace
GenerateIndentedLine("{", sb);
m_braceCount++;
if (m_insertCoopTerminationChecks)
{
// We have to check in event functions as well because the user can manually call these.
if (previousSymbol is GlobalFunctionDefinition ||
previousSymbol is WhileStatement ||
previousSymbol is DoWhileStatement ||
previousSymbol is ForLoop ||
previousSymbol is StateEvent)
{
GenerateIndentedLine(m_coopTerminationCheck, sb);
}
}
foreach (SYMBOL kid in cs.kids)
{
GenerateNodeToSB(cs, kid, sb);
}
// closing brace
m_braceCount--;
GenerateIndentedLine("}", sb);
}
public void OnError(SYMBOL sy)
{
switch (sy)
{
case SYMBOL.CASE: OnError(15); break;
case SYMBOL.WHILE: OnError(17); break;
case SYMBOL.RETURN: OnError(52); break;
//---------------------------------------------------------------------
case SYMBOL.SEMI: OnError(14); break;
case SYMBOL.COLON: OnError(5); break;
case SYMBOL.LP: OnError(9); break;
case SYMBOL.RP: OnError(4); break;
case SYMBOL.RB: OnError(12); break;
case SYMBOL.LC: OnError(8); break;
case SYMBOL.RC: OnError(13); break;
case SYMBOL.IN: OnError(62); break;
case SYMBOL.identsy: OnError(2); break;
default:
throw new CompilingException(string.Format("Error: unknown symbol:{0} expected", sy), pos);
}
}
/// <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]);
}
}
public void FindMark(SYMBOL smb, string mark, out string kind, out string form)
{
CogniPy.CNL.EN.InvTransform trans = new InvTransform(mark);
trans.Convert(smb as CogniPy.CNL.EN.paragraph);
var ckind = trans.GetMarkerKind();
var cform = trans.GetMarkerForm();
switch (ckind)
{
case InvTransform.EntityKind.Concept:
kind = "concept"; break;
case InvTransform.EntityKind.AnyRole:
kind = "role"; break;
case InvTransform.EntityKind.DataRole:
kind = "datarole"; break;
case InvTransform.EntityKind.DataType:
kind = "datatype"; break;
case InvTransform.EntityKind.Instance:
kind = "instance"; break;
default:
throw new InvalidOperationException();
}
form = cform == endict.WordKind.NormalForm ? "NormalForm" : (cform == endict.WordKind.PastParticiple ? "PastParticiple" : (cform == endict.WordKind.SimplePast ? "SimplePast" : (cform == endict.WordKind.PluralFormNoun ? "PluralFormNoun" : "PluralFormVerb")));
}
/// <summary>
/// Recursively called to transform each type of node. Will transform this
/// node, then all of its 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_datatypeLSL2CS[((Declaration)s).Datatype];
}
else if (s is Constant)
{
((Constant)s).Type = m_datatypeLSL2CS[((Constant)s).Type];
}
else if (s is TypecastExpression)
{
((TypecastExpression)s).TypecastType = m_datatypeLSL2CS[((TypecastExpression)s).TypecastType];
}
else if (s is GlobalFunctionDefinition && "void" != ((GlobalFunctionDefinition)s).ReturnType) // we don't need to translate "void"
{
((GlobalFunctionDefinition)s).ReturnType = m_datatypeLSL2CS[((GlobalFunctionDefinition)s).ReturnType];
}
for (int i = 0; i < s.kids.Count; i++)
{
if (!(s is Assignment || s is ArgumentDeclarationList) && s.kids[i] is Declaration)
{
AddImplicitInitialization(s, i);
}
TransformNode((SYMBOL)s.kids[i]);
}
}
/// <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, Dictionary <string, string> GlobalMethods, Dictionary <string, ObjectList> MethodArguements)
{
// 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)
{
if ("void" == ((GlobalFunctionDefinition)s).ReturnType) // we don't need to translate "void"
{
if (GlobalMethods != null && !GlobalMethods.ContainsKey(((GlobalFunctionDefinition)s).Name))
{
GlobalMethods.Add(((GlobalFunctionDefinition)s).Name, "void");
}
}
else
{
((GlobalFunctionDefinition)s).ReturnType = m_datatypeLSL2OpenSim[((GlobalFunctionDefinition)s).ReturnType];
if (GlobalMethods != null && !GlobalMethods.ContainsKey(((GlobalFunctionDefinition)s).Name))
{
GlobalMethods.Add(((GlobalFunctionDefinition)s).Name, ((GlobalFunctionDefinition)s).ReturnType);
MethodArguements.Add(((GlobalFunctionDefinition)s).Name, ((GlobalFunctionDefinition)s).kids);
}
}
}
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], null, null);
}
}
}
public static string getString(SYMBOL s)
{
switch (s)
{
case SYMBOL.CROSS:
return("\u2715");
case SYMBOL.ANCHOR:
return("\u2693");
case SYMBOL.LIGHTNING:
return("\u21AF");
case SYMBOL.FLAG:
return("\u2691");
case SYMBOL.PENCIL:
return("\u270E");
case SYMBOL.PLUS:
return("\u002B");
case SYMBOL.DELTA:
return("\u0394");
case SYMBOL.ARROW_UP_DOWN:
return("\u21C5");
case SYMBOL.CHECK:
return("\u2713");
case SYMBOL.SUN:
return("\u2600");
case SYMBOL.HEART:
return("\u2665");
case SYMBOL.DANGER:
return("\u26A0");
case SYMBOL.ARROW_RIGHT:
return("\u2023");
case SYMBOL.ARROW_UP:
return("\u2191");
case SYMBOL.ARROW_DOWN:
return("\u2193");
case SYMBOL.MERGE:
return("\u26D5");
case SYMBOL.ARROW_RIGHT_2:
return("\u21A6");
case SYMBOL.TRIANGLE_RIGHT:
return("\u22B3");
}
return(null);
}
/// <summary>
/// Prints text correctly indented, followed by a newline.
/// </summary>
/// <param name="s">String of text to print.</param>
/// <param name="sym">Symbol being generated to extract original line
/// number and column from.</param>
/// <returns>Properly indented string s followed by newline.</returns>
private void GenerateIndentedLine(string s, SYMBOL sym, StringBuilder sb)
{
GenerateIndented(s, sym, sb);
sb.Append("\n");
m_CSharpLine++;
m_CSharpCol = 1;
}
/// <summary>
/// Resets various counters and metadata.
/// </summary>
private void ResetCounters()
{
m_braceCount = 0;
m_CSharpLine = 0;
m_CSharpCol = 1;
m_positionMap = new Dictionary <KeyValuePair <int, int>, KeyValuePair <int, int> >();
m_astRoot = null;
}
/// <summary>
/// Prints text correctly indented, followed by a newline.
/// </summary>
/// <param name="s">String of text to print.</param>
/// <param name="sym">Symbol being generated to extract original line
/// number and column from.</param>
/// <returns>Properly indented string s followed by newline.</returns>
private string GenerateIndentedLine(string s, SYMBOL sym)
{
string retstr = GenerateIndented(s, sym) + "\n";
m_CSharpLine++;
m_CSharpCol = 1;
return(retstr);
}
/// <summary>
/// Prints text.
/// </summary>
/// <param name="s">String of text to print.</param>
/// <param name="sym">Symbol being generated to extract original line
/// number and column from.</param>
/// <returns>String s.</returns>
private void Generate(string s, SYMBOL sym, StringBuilder sb)
{
sb.Append(s);
if (null != sym)
{
m_positionMap.Add(new KeyValuePair <int, int>(m_CSharpLine, m_CSharpCol), new KeyValuePair <int, int>(sym.Line, sym.Position));
}
m_CSharpCol += s.Length;
}
public void Clear()
{
m_astRoot.kids = null;
m_astRoot.yylx = null;
m_astRoot.yyps = null;
m_astRoot = null;
m_positionMap = null;
m_warnings.Clear();
m_comms = null;
}
public override SYMBOL Action(Parser yyp)
{
SYMBOL yysym = base.Action(yyp);
object obj = yyp.m_symbols.Action(yyp, yysym, this.m_action);
if (obj != null)
{
yysym.m_dollar = obj;
}
return(yysym);
}
/// <summary>
/// Prints text.
/// </summary>
/// <param name="s">String of text to print.</param>
/// <param name="sym">Symbol being generated to extract original line
/// number and column from.</param>
/// <returns>String s.</returns>
private string Generate(string s, SYMBOL sym)
{
if (null != sym)
{
m_positionMap.Add(new KeyValuePair <int, int>(m_CSharpLine, m_CSharpCol), new KeyValuePair <int, int>(sym.Line, sym.Position));
}
m_CSharpCol += s.Length;
return(s);
}
/// <summary>
/// Attempt to recognize the given phonological environment string
/// </summary>
/// <param name="sEnvironment">phonological environment to recognize</param>
/// <returns>true if environment is recognized; false otherwise</returns>
public bool Recognize(string sEnvironment)
{
m_fSuccess = false; // Start distrustful.
try
{
InitParser(sEnvironment, m_saNaturalClasses, m_saSegments);
SYMBOL ast = m_parser.Parse(sEnvironment);
if (m_parser.Success)
{
m_fSuccess = true;
}
else
{
m_sErrorMessage = m_parser.ErrorMessage;
}
}
catch (CSToolsException exc)
{
StringBuilder sb = new StringBuilder();
if (m_parser.ErrorMessage == null)
{
sb.Append("<phonEnv status=\"syntax\" pos=\"");
if (m_parser.Position != -1)
{
sb.Append(m_parser.Position.ToString());
}
else
{
sb.Append(exc.nChar.ToString());
}
sb.Append("\" syntaxErrType=\"");
sb.Append(m_parser.SyntaxErrorType.ToString());
sb.Append("\">");
// Fix the string to be safe for XML.
if (sEnvironment != null && sEnvironment != "")
{
sEnvironment = sEnvironment.Replace("&", "&");
sEnvironment = sEnvironment.Replace("<", "<");
sEnvironment = sEnvironment.Replace(">", ">");
}
sb.Append(sEnvironment);
sb.Append("</phonEnv>");
}
else
{
sb.Append(m_parser.ErrorMessage);
}
m_sErrorMessage = sb.ToString();
m_parser.Success = false;
}
return(m_fSuccess);
}
/// <summary>
/// Generates the code for a Statement node.
/// </summary>
/// <param name="s">The Statement node.</param>
/// <returns>String containing C# code for Statement s.</returns>
private void GenerateStatement(SYMBOL previousSymbol, Statement s, StringBuilder sb)
{
string retstr = String.Empty;
bool printSemicolon = true;
bool transformToBlock = false;
if (m_insertCoopTerminationChecks)
{
// A non-braced single line do while structure cannot contain multiple statements.
// So to insert the termination check we change this to a braced control structure instead.
if (previousSymbol is WhileStatement ||
previousSymbol is DoWhileStatement ||
previousSymbol is ForLoop)
{
transformToBlock = true;
// FIXME: This will be wrongly indented because the previous for/while/dowhile will have already indented.
GenerateIndentedLine("{", sb);
GenerateIndentedLine(m_coopTerminationCheck, sb);
}
}
Indent(sb);
if (0 < s.kids.Count)
{
// Jump label prints its own colon, we don't need a semicolon.
printSemicolon = !(s.kids.Top is JumpLabel);
// If we encounter a lone Ident, we skip it, since that's a C#
// (MONO) error.
if (!(s.kids.Top is IdentExpression && 1 == s.kids.Count))
{
foreach (SYMBOL kid in s.kids)
{
GenerateNodeToSB(s, kid, sb);
}
}
}
if (printSemicolon)
{
GenerateLine(";", sb);
}
if (transformToBlock)
{
// FIXME: This will be wrongly indented because the for/while/dowhile is currently handling the unindent
GenerateIndentedLine("}", sb);
}
}
/// <summary>
/// Prints text correctly indented.
/// </summary>
/// <param name="s">String of text to print.</param>
/// <param name="sym">Symbol being generated to extract original line
/// number and column from.</param>
/// <returns>Properly indented string s.</returns>
private string GenerateIndented(string s, SYMBOL sym)
{
string retstr = Indent() + s;
if (null != sym)
{
m_positionMap.Add(new KeyValuePair <int, int>(m_CSharpLine, m_CSharpCol), new KeyValuePair <int, int>(sym.Line, sym.Position));
}
m_CSharpCol += s.Length;
return(retstr);
}
private bool expect(SYMBOL sy)
{
if (lex.sy == sy)
{
lex.InSymbol();
return(true);
}
else
{
error.OnError(sy); // add code throw a exception
return(false);
}
}
/// <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)
{
// m_log.DebugFormat("[LSL2CSCODETRANSFORMER]: Tranforming node {0}", 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])
{
// m_log.Debug("[LSL2CSCODETRANSFORMER]: Moving down level");
if (!(s is Assignment || s is ArgumentDeclarationList) && s.kids[i] is Declaration)
{
AddImplicitInitialization(s, i);
}
TransformNode((SYMBOL)s.kids[i]);
// m_log.Debug("[LSL2CSCODETRANSFORMER]: Moving up level");
}
}
}
/// <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;
m_datatypeLSL2CS = new Dictionary <string, string>()
{
{ "integer", "lsl_integer" },
{ "float", "lsl_float" },
{ "key", "lsl_string" },
{ "string", "lsl_string" },
{ "vector", "lsl_vector" },
{ "rotation", "lsl_rotation" },
{ "list", "lsl_list" }
};
}
public static void printThisTree(SYMBOL ast)
{
for (int i = 0; i < m_indent; i++)
{
Console.Write(" ");
}
Console.WriteLine(ast.ToString());
m_indent++;
foreach (SYMBOL s in ast.kids)
{
printThisTree(s);
}
m_indent--;
}
/// <summary>
/// Generates the code for a ForLoopStatement node.
/// </summary>
/// <param name="fls">The ForLoopStatement node.</param>
/// <returns>String containing C# code for ForLoopStatement fls.</returns>
private string GenerateForLoopStatement(ForLoopStatement fls)
{
string retstr = String.Empty;
int comma = fls.kids.Count - 1; // tells us whether to print a comma
// It's possible that all we have is an empty Ident, for example:
//
// for (x; x < 10; x++) { ... }
//
// Which is illegal in C# (MONO). We'll skip it.
if (fls.kids.Top is IdentExpression && 1 == fls.kids.Count)
{
return(retstr);
}
for (int i = 0; i < fls.kids.Count; i++)
{
SYMBOL s = (SYMBOL)fls.kids[i];
// Statements surrounded by parentheses in for loops
//
// e.g. for ((i = 0), (j = 7); (i < 10); (++i))
//
// are legal in LSL but not in C# so we need to discard the parentheses
//
// The following, however, does not appear to be legal in LLS
//
// for ((i = 0, j = 7); (i < 10); (++i))
//
// As of Friday 20th November 2009, the Linden Lab simulators appear simply never to compile or run this
// script but with no debug or warnings at all! Therefore, we won't deal with this yet (which looks
// like it would be considerably more complicated to handle).
while (s is ParenthesisExpression)
{
s = (SYMBOL)s.kids.Pop();
}
retstr += GenerateNode(s);
if (0 < comma--)
{
retstr += Generate(", ");
}
}
return(retstr);
}
/// <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.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>
/// Generates the code for an identifier
/// </summary>
/// <param name="id">The symbol name</param>
/// <param name="s">The Symbol node.</param>
/// <returns>String containing C# code for identifier reference.</returns>
private void GenerateIdentifier(string id, SYMBOL s, StringBuilder sb)
{
if (m_comms != null)
{
object value = m_comms.LookupModConstant(id);
if (value != null)
{
string retval = null;
if (value is int)
{
retval = String.Format("new LSL_Types.LSLInteger({0})", ((int)value).ToString());
}
else if (value is float)
{
retval = String.Format("new LSL_Types.LSLFloat({0})", ((float)value).ToString());
}
else if (value is string)
{
retval = String.Format("new LSL_Types.LSLString(\"{0}\")", ((string)value));
}
else if (value is OpenMetaverse.UUID)
{
retval = String.Format("new LSL_Types.key(\"{0}\")", ((OpenMetaverse.UUID)value).ToString());
}
else if (value is OpenMetaverse.Vector3)
{
retval = String.Format("new LSL_Types.Vector3(\"{0}\")", ((OpenMetaverse.Vector3)value).ToString());
}
else if (value is OpenMetaverse.Quaternion)
{
retval = String.Format("new LSL_Types.Quaternion(\"{0}\")", ((OpenMetaverse.Quaternion)value).ToString());
}
else
{
retval = id;
}
Generate(retval, s, sb);
return;
}
}
Generate(CheckName(id), s, sb);
return;
}
public static void Main(string[] argv)
{
StreamReader s = new StreamReader(argv[0]);
string source = s.ReadToEnd();
CSCodeGenerator cscg = new CSCodeGenerator();
string output = cscg.Convert(source);
if (1 < argv.Length && "-t" == argv[1])
{
Parser p = new LSLSyntax();
LSL2CSCodeTransformer codeTransformer = new LSL2CSCodeTransformer(p.Parse(source));
SYMBOL ast = codeTransformer.Transform();
printThisTree(ast);
}
else
{
Console.Write(output);
}
}
/// <summary>
/// Pass the new CodeTransformer an abstract syntax tree.
/// </summary>
/// <param name="astRoot">The root node of the AST.</param>
/// <param name="originalScript">The original script that we are converting</param>
public LSL2CSCodeTransformer(SYMBOL astRoot, string originalScript)
{
m_astRoot = astRoot;
m_originalScript = originalScript;
// let's populate the dictionary
if (null == m_datatypeLSL2OpenSim)
{
m_datatypeLSL2OpenSim = new Dictionary <string, string>
{
{ "integer", "LSL_Types.LSLInteger" },
{ "float", "LSL_Types.LSLFloat" },
{ "key", "LSL_Types.LSLString" },
{ "string", "LSL_Types.LSLString" },
{ "vector", "LSL_Types.Vector3" },
{ "rotation", "LSL_Types.Quaternion" },
{ "list", "LSL_Types.list" }
};
}
}
// This code checks for LSL of the following forms, and generates a
// warning if it finds them.
//
// list l = [ "foo" ];
// l = (l=[]) + l + ["bar"];
// (produces l=["foo","bar"] in SL but l=["bar"] in C#)
//
// integer i;
// integer j;
// i = (j = 3) + (j = 4) + (j = 5);
// (produces j=3 in SL but j=5 in C#)
//
// Without this check, that code passes compilation, but does not do what
// the end user expects, because LSL in SL evaluates right to left instead
// of left to right.
//
// The theory here is that producing an error and alerting the end user that
// something needs to change is better than silently generating incorrect code.
private void checkForMultipleAssignments(List <string> identifiers, SYMBOL s)
{
if (s is Assignment)
{
Assignment a = (Assignment)s;
string newident = null;
if (a.kids[0] is Declaration)
{
newident = ((Declaration)a.kids[0]).Id;
}
else if (a.kids[0] is IDENT)
{
newident = ((IDENT)a.kids[0]).yytext;
}
else if (a.kids[0] is IdentDotExpression)
{
newident = ((IdentDotExpression)a.kids[0]).Name; // +"." + ((IdentDotExpression)a.kids[0]).Member;
}
else
{
AddWarning(String.Format("Multiple assignments checker internal error '{0}' at line {1} column {2}.",
a.kids[0].GetType(), ((SYMBOL)a.kids[0]).Line - 1, ((SYMBOL)a.kids[0]).Position));
}
if (identifiers.Contains(newident))
{
AddWarning(String.Format("Multiple assignments to '{0}' at line {1} column {2}; results may differ between LSL and C#.",
newident, ((SYMBOL)a.kids[0]).Line - 1, ((SYMBOL)a.kids[0]).Position));
}
identifiers.Add(newident);
}
int index;
for (index = 0; index < s.kids.Count; index++)
{
checkForMultipleAssignments(identifiers, (SYMBOL)s.kids[index]);
}
}
bool s_exp24()
{
while (lex.sy == SYMBOL.RELOP || lex.sy == SYMBOL.IS || lex.sy == SYMBOL.IN || lex.sy == SYMBOL.AS)
{
SYMBOL sy = lex.sy;
SYMBOL2 Opr = lex.opr;
lex.InSymbol();
switch (sy)
{
case SYMBOL.RELOP:
s_exp9();
switch (Opr)
{
case SYMBOL2.GTR: gen.emit(INSTYPE.GTR); break;
case SYMBOL2.LSS: gen.emit(INSTYPE.LSS); break;
case SYMBOL2.LEQ: gen.emit(INSTYPE.LEQ); break;
case SYMBOL2.GEQ: gen.emit(INSTYPE.GEQ); break;
}
break;
case SYMBOL.IN:
s_exp9();
gen.emit(INSTYPE.LSS);
break;
case SYMBOL.IS:
s_var(true);
s_call(Constant.FUNC_IS_TYPE, 2);
break;
case SYMBOL.AS:
s_var(true);
s_call(Constant.FUNC_CAST_VALUE_TYPE, 2);
break;
}
}
return(true);
}
public Numeric(SYMBOL sy, Sym sym)
{
switch (sy)
{
case SYMBOL.intcon:
ty = NUMTYPE.intcon;
value = sym.inum;
break;
case SYMBOL.floatcon:
ty = NUMTYPE.doublecon;
value = sym.fnum;
break;
case SYMBOL.stringcon:
ty = NUMTYPE.stringcon;
value = sym.stab;
break;
case SYMBOL.nullsy:
ty = NUMTYPE.nullcon;
value = null;
break;
case SYMBOL.VOID:
ty = NUMTYPE.voidcon;
value = null;
break;
case SYMBOL.truesy:
ty = NUMTYPE.boolcon;
value = true;
break;
case SYMBOL.falsesy:
ty = NUMTYPE.boolcon;
value = false;
break;
}
}
/// <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>
/// <param name="GlobalMethods"> </param>
/// <param name="MethodArguements"> </param>
/// <param name="scopesParent"> </param>
/// <param name="scopeCurrent"> </param>
private void TransformNode(SYMBOL s, Dictionary <string, string> GlobalMethods,
Dictionary <string, ObjectList> MethodArguements, List <int> scopesParent,
int scopeCurrent)
{
// 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 dec = (Declaration)s;
dec.Datatype = m_datatypeLSL2OpenSim[dec.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)
{
GlobalFunctionDefinition fun = (GlobalFunctionDefinition)s;
if ("void" == fun.ReturnType) // we don't need to translate "void"
{
if (GlobalMethods != null && !GlobalMethods.ContainsKey(fun.Name))
{
GlobalMethods.Add(fun.Name, "void");
}
}
else
{
fun.ReturnType =
m_datatypeLSL2OpenSim[fun.ReturnType];
if (GlobalMethods != null && !GlobalMethods.ContainsKey(fun.Name))
{
GlobalMethods.Add(fun.Name, fun.ReturnType);
MethodArguements.Add(fun.Name, (s).kids);
}
}
//Reset the variables, we changed events
m_currentEvent = fun.Name;
m_localVariableValues.Add("global_function_" + fun.Name, new Dictionary <string, SYMBOL>());
m_localVariableValuesStr.Add("global_function_" + fun.Name, new Dictionary <string, string>());
m_duplicatedLocalVariableValues.Add("global_function_" + fun.Name, new Dictionary <string, SYMBOL>());
m_localVariableScope.Add("global_function_" + fun.Name, new Dictionary <string, int>());
// this is a new function, lets clear the parent scopes and set the current scope to this
scopesParent.Clear();
scopeCurrent = s.pos;
scopesParent.Add(scopeCurrent);
}
else if (s is State)
{
//Reset the variables, we changed events
State evt = (State)s;
m_currentState = evt.Name;
}
else if (s is StateEvent)
{
//Reset the variables, we changed events
StateEvent evt = (StateEvent)s;
m_currentEvent = evt.Name;
m_localVariableValues.Add(m_currentState + "_" + evt.Name, new Dictionary <string, SYMBOL>());
m_localVariableValuesStr.Add(m_currentState + "_" + evt.Name, new Dictionary <string, string>());
m_duplicatedLocalVariableValues.Add(m_currentState + "_" + evt.Name, new Dictionary <string, SYMBOL>());
m_localVariableScope.Add(m_currentState + "_" + evt.Name, new Dictionary <string, int>());
// this is a new state event, lets clear the parent scopes and set the current scope to this
scopesParent.Clear();
scopeCurrent = s.pos;
scopesParent.Add(scopeCurrent);
}
else if (s is ArgumentDeclarationList)
{
ArgumentDeclarationList adl = (ArgumentDeclarationList)s;
foreach (SYMBOL child in adl.kids)
{
Declaration d = child as Declaration;
if (d != null)
{
m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()][d.Id] = null;
}
}
//m_duplicatedLocalVariableValues.Add(m_currentState + "_" + evt.Name, new Dictionary<string, SYMBOL>());
}
else if (s is GlobalVariableDeclaration)
{
GlobalVariableDeclaration gvd = (GlobalVariableDeclaration)s;
foreach (SYMBOL child in gvd.kids)
{
if (child is Assignment)
{
bool isDeclaration = false;
string decID = "";
foreach (SYMBOL assignmentChild in child.kids)
{
if (assignmentChild is Declaration)
{
Declaration d = (Declaration)assignmentChild;
decID = d.Id;
isDeclaration = true;
}
else if (assignmentChild is IdentExpression)
{
IdentExpression identEx = (IdentExpression)assignmentChild;
if (isDeclaration)
{
if (m_globalVariableValues.ContainsKey(decID))
{
m_duplicatedGlobalVariableValues[decID] = identEx;
}
m_globalVariableValues[decID] = identEx.Name;
}
}
else if (assignmentChild is ListConstant)
{
ListConstant listConst = (ListConstant)assignmentChild;
foreach (SYMBOL listChild in listConst.kids)
{
if (listChild is ArgumentList)
{
ArgumentList argList = (ArgumentList)listChild;
int i = 0;
bool changed = false;
object[] p = new object[argList.kids.Count];
foreach (SYMBOL objChild in argList.kids)
{
p[i] = objChild;
if (objChild is IdentExpression)
{
IdentExpression identEx = (IdentExpression)objChild;
if (m_globalVariableValues.ContainsKey(identEx.Name))
{
changed = true;
p[i] = new IdentExpression(identEx.yyps,
m_globalVariableValues[identEx.Name])
{
pos = objChild.pos,
m_dollar = objChild.m_dollar
};
}
}
i++;
}
if (changed)
{
argList.kids = new ObjectList();
foreach (object o in p)
{
argList.kids.Add(o);
}
}
if (isDeclaration)
{
if (m_globalVariableValues.ContainsKey(decID))
{
m_duplicatedGlobalVariableValues[decID] = listConst;
}
m_globalVariableValues[decID] = listConst.Value;
}
}
}
}
else if (assignmentChild is VectorConstant || assignmentChild is RotationConstant)
{
Constant listConst = (Constant)assignmentChild;
int i = 0;
bool changed = false;
object[] p = new object[listConst.kids.Count];
foreach (SYMBOL objChild in listConst.kids)
{
p[i] = objChild;
if (objChild is IdentExpression)
{
IdentExpression identEx = (IdentExpression)objChild;
if (m_globalVariableValues.ContainsKey(identEx.Name))
{
changed = true;
p[i] = new IdentExpression(identEx.yyps,
m_globalVariableValues[identEx.Name])
{
pos = objChild.pos,
m_dollar = objChild.m_dollar
};
}
}
i++;
}
if (changed)
{
listConst.kids = new ObjectList();
foreach (object o in p)
{
listConst.kids.Add(o);
}
}
if (isDeclaration)
{
if (m_globalVariableValues.ContainsKey(decID))
{
m_duplicatedGlobalVariableValues[decID] = listConst;
}
m_globalVariableValues[decID] = listConst.Value;
}
}
else if (assignmentChild is Constant)
{
Constant identEx = (Constant)assignmentChild;
if (isDeclaration)
{
if (m_globalVariableValues.ContainsKey(decID))
{
m_duplicatedGlobalVariableValues[decID] = identEx;
}
m_globalVariableValues[decID] = identEx.Value;
}
}
}
}
}
}
else if (s is Assignment && m_currentEvent != "")
{
Assignment ass = (Assignment)s;
bool isDeclaration = false;
string decID = "";
foreach (SYMBOL assignmentChild in ass.kids)
{
if (assignmentChild is Declaration)
{
Declaration d = (Declaration)assignmentChild;
decID = d.Id;
isDeclaration = true;
}
else if (assignmentChild is IdentExpression)
{
IdentExpression identEx = (IdentExpression)assignmentChild;
if (isDeclaration)
{
if (m_localVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(decID) &&
!m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(decID) &&
scopesParent.Contains(m_localVariableScope[GetLocalVariableDictionaryKey()][decID]))
{
m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()][decID] =
m_localVariableValues[GetLocalVariableDictionaryKey()][decID];
}
m_localVariableValues[GetLocalVariableDictionaryKey()][decID] = identEx;
m_localVariableValuesStr[GetLocalVariableDictionaryKey()][decID] = identEx.Name;
m_localVariableScope[GetLocalVariableDictionaryKey()][decID] = scopeCurrent;
}
}
else if (assignmentChild is ListConstant)
{
ListConstant listConst = (ListConstant)assignmentChild;
foreach (SYMBOL listChild in listConst.kids)
{
if (listChild is ArgumentList)
{
ArgumentList argList = (ArgumentList)listChild;
int i = 0;
bool changed = false;
object[] p = new object[argList.kids.Count];
foreach (SYMBOL objChild in argList.kids)
{
p[i] = objChild;
if (objChild is IdentExpression)
{
IdentExpression identEx = (IdentExpression)objChild;
if (
m_localVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(
identEx.Name))
{
changed = true;
p[i] = new IdentExpression(identEx.yyps,
m_localVariableValuesStr[
GetLocalVariableDictionaryKey()][identEx.Name
])
{
pos = objChild.pos,
m_dollar = objChild.m_dollar
};
}
}
i++;
}
if (changed)
{
argList.kids = new ObjectList();
foreach (object o in p)
{
argList.kids.Add(o);
}
}
if (isDeclaration)
{
if (m_localVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(decID) &&
!m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(
decID) &&
scopesParent.Contains(
m_localVariableScope[GetLocalVariableDictionaryKey()][decID]))
{
m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()][decID] =
m_localVariableValues[GetLocalVariableDictionaryKey()][decID];
}
m_localVariableValues[GetLocalVariableDictionaryKey()][decID] = listConst;
m_localVariableValuesStr[GetLocalVariableDictionaryKey()][decID] = listConst.Value;
m_localVariableScope[GetLocalVariableDictionaryKey()][decID] = scopeCurrent;
}
}
}
}
else if (assignmentChild is VectorConstant || assignmentChild is RotationConstant)
{
Constant listConst = (Constant)assignmentChild;
int i = 0;
bool changed = false;
object[] p = new object[listConst.kids.Count];
foreach (SYMBOL objChild in listConst.kids)
{
p[i] = objChild;
if (objChild is IdentExpression)
{
IdentExpression identEx = (IdentExpression)objChild;
if (m_localVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(identEx.Name))
{
changed = true;
p[i] = new IdentExpression(identEx.yyps,
m_localVariableValuesStr[GetLocalVariableDictionaryKey()]
[identEx.Name])
{
pos = objChild.pos,
m_dollar = objChild.m_dollar
};
}
}
i++;
}
if (changed)
{
listConst.kids = new ObjectList();
foreach (object o in p)
{
listConst.kids.Add(o);
}
}
if (isDeclaration)
{
if (m_localVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(decID) &&
!m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(decID) &&
scopesParent.Contains(m_localVariableScope[GetLocalVariableDictionaryKey()][decID]))
{
m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()][decID] =
m_localVariableValues[GetLocalVariableDictionaryKey()][decID];
}
m_localVariableValues[GetLocalVariableDictionaryKey()][decID] = listConst;
m_localVariableValuesStr[GetLocalVariableDictionaryKey()][decID] = listConst.Value;
m_localVariableScope[GetLocalVariableDictionaryKey()][decID] = scopeCurrent;
}
}
else if (assignmentChild is Constant)
{
Constant identEx = (Constant)assignmentChild;
if (isDeclaration)
{
if (m_localVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(decID) &&
!m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()].ContainsKey(decID) &&
scopesParent.Contains(m_localVariableScope[GetLocalVariableDictionaryKey()][decID]))
{
m_duplicatedLocalVariableValues[GetLocalVariableDictionaryKey()][decID] =
m_localVariableValues[GetLocalVariableDictionaryKey()][decID];
}
m_localVariableValues[GetLocalVariableDictionaryKey()][decID] = identEx;
m_localVariableValuesStr[GetLocalVariableDictionaryKey()][decID] = identEx.Value;
m_localVariableScope[GetLocalVariableDictionaryKey()][decID] = scopeCurrent;
}
}
}
}
/*if(s is Statement)
* {
* if(s.kids.Count == 1 && s.kids[0] is Assignment)
* {
* Assignment assignment = (Assignment)s.kids[0];
* object[] p = new object[assignment.kids.Count];
* int i = 0;
* int toRemove = -1;
* foreach(SYMBOL assignmentChild in assignment.kids)
* {
* p[i] = assignmentChild;
* if(assignmentChild is Declaration)
* {
* Declaration d = (Declaration)assignmentChild;
* if(m_allVariableValues.Contains(d.Id))
* toRemove = i;
* else
* m_allVariableValues.Add(d.Id);
* }
* i++;
* }
* if(toRemove != -1)
* {
* List<object> ps = new List<object>();
* foreach(object obj in p)
* ps.Add(obj);
* ps[toRemove] = new IDENT(null)
* {
* kids = new ObjectList(),
* pos = ((SYMBOL)ps[toRemove]).pos,
* m_dollar = ((SYMBOL)ps[toRemove]).m_dollar,
* yylval = ((SYMBOL)ps[toRemove]).yylval,
* yylx = ((SYMBOL)ps[toRemove]).yylx,
* yyps = ((SYMBOL)ps[toRemove]).yyps,
* yytext = ps[toRemove] is Declaration ?
* ((Declaration)ps[toRemove]).Id
* : ((SYMBOL)ps[toRemove]).yyname,
* };
* ((SYMBOL)s.kids[0]).kids = new ObjectList();
* foreach(object obj in ps)
* if(obj != null)
* ((SYMBOL)s.kids[0]).kids.Add(obj);
* }
* }
* }*/
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])
{
continue;
}
bool scopeAdded = false;
// we need to keep track of the scope for dulicate variables
if ((s is IfStatement) || (s is WhileStatement) || (s is ForLoopStatement) || (s is DoWhileStatement))
{
scopeCurrent = ((SYMBOL)s.kids[i]).pos;
scopesParent.Add(scopeCurrent);
scopeAdded = true;
}
if (!(s is Assignment || s is ArgumentDeclarationList) && s.kids[i] is Declaration)
{
AddImplicitInitialization(s, i);
}
TransformNode((SYMBOL)s.kids[i], null, null, scopesParent, scopeCurrent);
// we need to remove the current scope from the parent since we are no longer in that scope
if (scopeAdded)
{
scopesParent.Remove(scopeCurrent);
}
}
}
public Token(SYMBOL sy, SYMBOL2 opr)
: this()
{
this.sy = sy;
this.opr = opr;
}
public SYMBOL ksy; // key work symbol
#endregion Fields
#region Constructors
public JKey(string key, SYMBOL ksy)
{
this.key = key;
this.ksy = ksy;
}
public void OnError(SYMBOL sy)
{
switch (sy)
{
case SYMBOL.CASE: OnError(15); break;
case SYMBOL.WHILE: OnError(17); break;
case SYMBOL.RETURN: OnError(52); break;
//---------------------------------------------------------------------
case SYMBOL.SEMI: OnError(14); break;
case SYMBOL.COLON: OnError(5); break;
case SYMBOL.LP: OnError(9); break;
case SYMBOL.RP: OnError(4); break;
case SYMBOL.RB: OnError(12); break;
case SYMBOL.LC: OnError(8); break;
case SYMBOL.RC: OnError(13); break;
case SYMBOL.IN: OnError(62); break;
case SYMBOL.identsy: OnError(2); break;
default:
throw new CompilingException(string.Format("Error: unknown symbol:{0} expected", sy), pos);
}
}
