|
public static GetChildren ( Production parent ) : |
||
| parent | Production | |
| return | ||
public override Node ExitStatement(Production node)
{
if (replaceReturn == false)
{
return(node);
}
Node n = GrammaticaNodeUtils.FindChildOf(node, new string[1] {
"Return_Statement"
});
if (n != null)
{
Node returnStatement = GrammaticaNodeUtils.FindChildOf(n, new string[1] {
"RETURN"
});
if (returnStatement != null)
{
ArrayList returnStatementChildren = GrammaticaNodeUtils.GetChildren((Production)n);
returnStatementChildren.Insert(1, GrammaticaNodeUtils.CreateEqualToken());
returnStatementChildren.Insert(1, GrammaticaNodeUtils.CreateSpaceToken());
}
}
return(node);
}
public Node RemoveTypeFromMain(Production node)
{
Production tempType = (Production)GrammaticaNodeUtils.FindChildOf(node, "Type");
ArrayList tempVoid = GrammaticaNodeUtils.GetChildren(tempType);
if (tempVoid != null)
{
tempVoid.RemoveAt(0);
tempVoid.Insert(0, GrammaticaNodeUtils.CreateVoidToken());
}
return(node);
}
public Node RemoveSemanticParams(Production node)
{
ArrayList lista = GrammaticaNodeUtils.GetChildren(node);
ArrayList trash = new ArrayList();
for (int i = 0; i < lista.Count; i++)
{
if ((((Node)lista[i]).GetName().Equals("DOUBLE_DOT")))
{
trash.Add(lista[i]);
}
if ((((Node)lista[i]).GetName().Equals("SemanticalParameters")))
{
trash.Add(lista[i]);
}
if ((((Node)lista[i]).GetName().Equals("Register_Func")))
{
trash.Add(lista[i]);
}
if ((((Node)lista[i]).GetName().Equals("Packoffset_Func")))
{
trash.Add(lista[i]);
}
}
for (int j = 0; j < trash.Count; j++)
{
lista.Remove(trash[j]);
}
trash = new ArrayList();
// Remove spaces left
for (int i = lista.Count - 1; i >= 0; i--)
{
if ((((Node)lista[i]).GetName().Equals("WS")))
{
trash.Add(lista[i]);
}
else
{
break;
}
}
for (int j = 0; j < trash.Count; j++)
{
lista.Remove(trash[j]);
}
return(node);
}
// Dado um nodo pai, e o índice do nodo filho, esta função busca em índeces anteriores e posteriores
// os comentários pertinentes e move para dentro do nodeToPut.
// O objetivo desta função é preparar os nodos para serem movidos, levando consigo seus comentários.
public static void MovePreviousLineRelatedCommentToInsideANode(Production nodeToSearch, int indexOfTheRelatedInstruction, Production nodeToPut)
{
ArrayList whereSearch = GrammaticaNodeUtils.GetChildren(nodeToSearch);
ArrayList wherePut = GrammaticaNodeUtils.GetChildren(nodeToPut);
int WSPos = indexOfTheRelatedInstruction - 1; // WS is always one before Function_Param
if (WSPos >= 0)
{
Production WS = (Production)whereSearch[WSPos];
if (WS.GetName().Equals("WS")) // WS is optional
{
ArrayList tokens = GrammaticaNodeUtils.GetChildren(WS);
// Search the first newline
int afterTheFirstNewLine = tokens.Count;
for (int j = tokens.Count - 3; j > 0; j--)
{
if (((Token)tokens[j]).GetName().Equals("NEWLINE") ||
((Token)tokens[j]).GetName().Equals("NEWLINE2") ||
((Token)tokens[j]).GetName().Equals("NEWLINE3"))
{
afterTheFirstNewLine = j;
break;
}
}
// add all after the first newline to variable declaration
ArrayList toRemove = new ArrayList();
for (int j = afterTheFirstNewLine; j < tokens.Count; j++)
{
// adds to param childrens which will be moved to outside the function
if (!((Token)tokens[j]).GetName().Equals("WHITESPACE") &&
!((Token)tokens[j]).GetName().Equals("TAB"))
{
wherePut.Insert(0, tokens[j]);
toRemove.Add(tokens[j]);
}
}
for (int j = 0; j < toRemove.Count; j++)
{
tokens.Remove(toRemove[j]);
}
}
}
}
public override Node ExitParameters(Production node)
{
ArrayList listOfParams = GrammaticaNodeUtils.GetChildren(node);
ArrayList trash = new ArrayList();
for (int i = 0; i < listOfParams.Count; i++)
{
if ((((Node)listOfParams[i]).GetName().Equals("WS")))
{
trash.Add(listOfParams[i]);
}
}
for (int j = 0; j < trash.Count; j++)
{
listOfParams.Remove(trash[j]);
}
return(node);
}
public bool MarkIfNodeIsFuncSemanticalParameter(Production node, string tokenType, string to)
{
ArrayList lista = GrammaticaNodeUtils.GetChildren(node);
for (int i = 0; i < lista.Count; i++)
{
if ((((Node)lista[i]).GetName().Equals("SemanticalParameters")))
{
Token name = (Token)GrammaticaNodeUtils.FindChildOf(node, new string[3] {
"SemanticalParameters", "InOutSemanticalParameters", tokenType
});
if (name != null)
{
replaceReturnFor = to;
return(true);
}
return(false);
}
}
return(false);
}
/**
* Move the global vars to outside function declaration.
*/
public override Node ExitFile(Production node)
{
ArrayList lista = GrammaticaNodeUtils.GetChildren(node);
Node mainFunction = null;
for (int i = 0; i < lista.Count; i++)
{
mainFunction = (Node)lista[i];
if (mainFunction.GetName().Equals("Function_OR_Variable_Declaration"))
{
// move related comment in previous line to inside this function.
GrammaticaNodeUtils.MovePreviousLineRelatedCommentToInsideANode(node, i, (Production)mainFunction);
}
}
// search for the first main function.
for (int i = 0; i < lista.Count; i++)
{
mainFunction = (Node)lista[i];
if (mainFunction.GetName().Equals("Function_OR_Variable_Declaration"))
{
if (mainFunctions.Contains(((Token)GrammaticaNodeUtils.FindChildOf(mainFunction, "IDENTIFIER")).GetImage()))
{
break;
}
}
}
// put the global vars before the first MainFunction
foreach (Node var in globalVars)
{
lista.Insert(lista.IndexOf(mainFunction), var);
//GrammaticaNodeUtils.SetParent(var, node);
}
return(node);
}
// Dado um nodo pai, e o índice do nodo filho, esta função busca em índeces anteriores e posteriores
// os comentários pertinentes e move para dentro do nodeToPut.
// O objetivo desta função é preparar os nodos para serem movidos, levando consigo seus comentários.
public static void MoveSameLineRelatedCommentToInsideANode(Production nodeToSearch, int indexOfTheRelatedInstruction, Production nodeToPut)
{
ArrayList whereSearch = GrammaticaNodeUtils.GetChildren(nodeToSearch);
ArrayList wherePut = GrammaticaNodeUtils.GetChildren(nodeToPut);
// find related comment after the comma and before the \n
Production relatedWS = null;
Token relatedComma = null;
// PARAM [WS] COMMA [WS]
int WSPos = indexOfTheRelatedInstruction + 2; // WS is always one before Function_Param
if (WSPos <= whereSearch.Count)
{
relatedWS = (Production)whereSearch[WSPos];
if (!relatedWS.GetName().Equals("WS")) // First WS is optional
{
relatedWS = null;
relatedComma = (Token)whereSearch[WSPos];
WSPos++;
if (WSPos <= whereSearch.Count)
{
relatedWS = (Production)whereSearch[WSPos];
}
}
else
{
relatedComma = (Token)whereSearch[WSPos - 1];
}
}
// move to related comment after the comma and before the \n
if (relatedWS != null)
{
ArrayList toRemove = new ArrayList();
// add all after the comma and before newline
ArrayList tokens = GrammaticaNodeUtils.GetChildren(relatedWS);
for (int j = 0; j < tokens.Count; j++)
{
// adds to param childrens which will be moved to outside the function
if (((Token)tokens[j]).GetName().Equals("NEWLINE") ||
((Token)tokens[j]).GetName().Equals("NEWLINE2") ||
((Token)tokens[j]).GetName().Equals("NEWLINE3"))
{
wherePut.Add(tokens[j]);
toRemove.Add(tokens[j]);
break;
}
wherePut.Add(tokens[j]);
toRemove.Add(tokens[j]);
}
tokens.Clear();
for (int j = 0; j < toRemove.Count; j++)
{
tokens.Remove(toRemove[j]);
}
}
// remove comma
whereSearch.Remove(relatedComma);
}
// For each param in every main HLSL function
// Move the uniform and varying params outside the function with his own comments
public override Node ExitListOfParams(Production node)
{
ArrayList listOfParams = GrammaticaNodeUtils.GetChildren(node);
// Only main mainFunctions.
// Based on the presence of in, out or inout keywords
if (!isMain)
{
return(node);
}
isMain = false;
// Searching params that will be removed at ExitFunctionParam
for (int i = 0; i < listOfParams.Count; i++)
{
if (!(listOfParams[i] is Production))
{
continue;
}
Production functionParam = (Production)listOfParams[i];
functionParam = (Production)CheckIfThisNodeIsSemanticAndRemoveIfItIs(functionParam);
// Only uniform params are moved
Node n = GrammaticaNodeUtils.FindChildOf(functionParam,
new string[1] {
"Variable_Declaration"
});
if (n != null) // Param found
// Getting childrens of it
{
Production variableDeclaration = (Production)n;
variableDeclaration = (Production)RemoveSemanticParams(variableDeclaration);
ArrayList variableDeclarationChildren = GrammaticaNodeUtils.GetChildren(variableDeclaration);
// add dot_comma and new line
variableDeclarationChildren.Add(GrammaticaNodeUtils.CreateDotCommaToken());
// move related comment in previous line to inside this param.
GrammaticaNodeUtils.MovePreviousLineRelatedCommentToInsideANode(node, i, variableDeclaration);
// move related commnet in the same line after the comma but before \n to this param.
GrammaticaNodeUtils.MoveSameLineRelatedCommentToInsideANode(node, i, variableDeclaration);
// add varying to all non-uniform parameters
Node hasUniform = GrammaticaNodeUtils.FindChildOf(variableDeclaration,
new string[2] {
"Storage_Class", "UNIFORM"
});
if (hasUniform == null)
{
GrammaticaNodeUtils.GetChildren(variableDeclaration).Insert(0, GrammaticaNodeUtils.CreateSpaceToken());
GrammaticaNodeUtils.GetChildren(variableDeclaration).Insert(0, GrammaticaNodeUtils.CreateVaryingToken());
GrammaticaNodeUtils.GetChildren(variableDeclaration).Insert(0, GrammaticaNodeUtils.CreateNewLineToken());
}
// move uniform to outside.
globalVars.Add(variableDeclaration);
// remove from param.
GrammaticaNodeUtils.GetChildren(functionParam).Remove(variableDeclaration);
}
}
ArrayList trash = new ArrayList();
// cleaning the trash: Spaces, commas and newlines before the ) of the function
for (int i = listOfParams.Count - 1; i >= 0; i--)
{
if (listOfParams[i] is Production)
{
if (((Production)listOfParams[i]).GetChildCount() == 0 ||
((Production)listOfParams[i]).GetName().Equals("WS"))
{
trash.Add(listOfParams[i]);
}
else
{
break;
}
}
if (listOfParams[i] is Token)
{
if (((Token)listOfParams[i]).GetName().Equals("COMMA"))
{
trash.Add(listOfParams[i]);
}
}
}
for (int j = 0; j < trash.Count; j++)
{
listOfParams.Remove(trash[j]);
}
return(node);
}
public override Node ExitFunctionConstructorCallOrVariableDeclaration(Production node)
{
Token identifier = (Token)GrammaticaNodeUtils.FindChildOf(node, new string[2] {
"Type", "IDENTIFIER"
});
if (identifier == null)
{
return(node);
}
replaceIntrinsicFunc(identifier);
// mul(term, term) => term * term
if (identifier.GetImage().Equals("mul"))
{
identifier.AddValue("");
Node virgula = GrammaticaNodeUtils.FindChildOf(node, new string[2] {
"PartOf_Constructor_Call", "COMMA"
});
virgula.AddValue(" * ");
}
// cross(T,N) => cross(N,T).
if (identifier.GetImage().Equals("cross"))
{
Production listOfParam = (Production)GrammaticaNodeUtils.FindChildOf(node, "PartOf_Constructor_Call");
Node exp1 = GrammaticaNodeUtils.FindChildOf(listOfParam, "Expression", 1);
Node exp2 = GrammaticaNodeUtils.FindChildOf(listOfParam, "Expression", 2);
GrammaticaNodeUtils.SwapChildrenPosition(listOfParam, exp1, exp2);
}
// saturate(x) => clamp(x,0.0,1.0).
if (identifier.GetImage().Equals("saturate"))
{
identifier.AddValue("clamp");
var listOfParam = (Production)GrammaticaNodeUtils.FindChildOf(node, "PartOf_Constructor_Call");
var children = GrammaticaNodeUtils.GetChildren(listOfParam);
children.Insert(2, GrammaticaNodeUtils.CreateCommaToken());
children.Insert(3, GrammaticaNodeUtils.CreateNumberToken(0.0f));
children.Insert(4, GrammaticaNodeUtils.CreateCommaToken());
children.Insert(5, GrammaticaNodeUtils.CreateNumberToken(1.0f));
}
// add dependent function
Node n = GrammaticaNodeUtils.FindChildOf(node, "PartOf_Constructor_Call");
if (n != null && identifier != null && functionScope != null)
{
// function call or constructor call.
dependencyGraph.SearchDependant(identifier.GetImage()).AddCallsBy(functionScope);
}
// Adds only globalVars.
if (!scopeVars.Contains(identifier.GetImage()))
{
dependencyGraph.SearchDependant(identifier.GetImage()).AddCallsBy(functionScope);
}
return(node);
}