/************************ convertSubTaskOperator *******************************
void convertSubTaskOperator(Stack stack, Out out, Element *pElement)
Purpose:
This function handles the case of an operator token.
The operators in the stack with a higher or equal precedence get outted
and the new operator gets pushed to the stack.
Parameters:
I/O Stack stack The current stack.
O Out out The out structure used in the conversion.
I Element *pElement The operator element.
Returns:
stack parm - the updated stack.
out parm - the updated out structure.
Notes:
This is a sub task of the query conversion from infix format to
postfix format.
*******************************************************************************/
void convertSubTaskOperator(Stack stack, Out out, Element *pElement)
{
while(isEmpty(stack) == FALSE && pElement->iPrecedence <= topElement(stack).iPrecedence)
//loop until the stack is empty or there's no more operator in the stack with a lower
//precedence than the top of the stack
{
addOut(out, pop(stack)); //POP and OUT the higher precedence operator from the stack
}
push(stack, *pElement);
}
types::Function::ReturnValue sci_macrovar(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
if (in.size() != 1)
{
Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), "macrovar" , 1);
return types::Function::Error;
}
if (_iRetCount != 1)
{
Scierror(999, _("%s: Wrong number of output arguments: %d expected.\n"), "macrovar" , 1);
return types::Function::Error;
}
types::Macro* pM = NULL;
switch (in[0]->getType())
{
case types::InternalType::ScilabMacro:
{
pM = in[0]->getAs<types::Macro>();
break;
}
case types::InternalType::ScilabMacroFile:
{
types::MacroFile* pMF = in[0]->getAs<types::MacroFile>();
pM = pMF->getMacro();
break;
}
default :
Scierror(999, _("%s: Wrong type for input arguments: macro expected.\n"), "macrovar");
return types::Function::Error;
}
ast::MacrovarVisitor visit;
addIn(visit, pM->getInputs());
addOut(visit, pM->getOutputs());
pM->getBody()->accept(visit);
types::List* pL = new types::List();
pL->append(createString(visit.getIn()));
pL->append(createString(visit.getOut()));
pL->append(createString(visit.getExternal()));
pL->append(createString(visit.getCalled()));
pL->append(createString(visit.getLocal()));
out.push_back(pL);
return types::Function::OK;
}
/*********************** convertSubTaskRemainingStack **************************
int convertSubTaskRemainingStack(Stack stack, Out out)
Purpose:
This function handles the rest of the stack once we've gone through
all of the tokens in the input. It also handles the case of a leftover
unmatched parenthesis in the stack.
Parameters:
I/O Stack stack The current stack.
O Out out The out structure used in the conversion.
Returns:
stack parm - the freed stack.
out parm - the final out structure.
Notes:
This is a sub task of the query conversion from infix format to
postfix format.
*******************************************************************************/
int convertSubTaskRemainingStack(Stack stack, Out out)
{
while (isEmpty(stack) == FALSE) //goes through the remaining stack until empty
{
if (topElement(stack).iCategory == CAT_LPAREN)//if an unmatched ( is found
{
freeStack(stack); //at this point we are done using the stack
return WARN_MISSING_RPAREN; //return error
}
addOut(out, pop(stack)); //POP and OUT the stack
}
freeStack(stack); //at this point we are done using the stack
}
/************************** convertSubTaskRParen *******************************
int convertSubTaskRParen(Stack stack, Out out)
Purpose:
This function handles the case of a right parenthesis token.
The elements in the stack get outted until we find the matching
right parenthesis if there is one.
Parameters:
I/O Stack stack The current stack.
O Out out The out structure used in the conversion.
Returns:
stack parm - the updated stack.
out parm - the updated out structure.
Notes:
This is a sub task of the query conversion from infix format to
postfix format.
*******************************************************************************/
int convertSubTaskRParen(Stack stack, Out out)
{
while (isEmpty(stack) == FALSE && topElement(stack).iCategory != CAT_LPAREN)
{
addOut(out, pop(stack)); //POP and OUT content of the stack until left parenthesis is found
}
if (isEmpty(stack) == TRUE) //if we didn't find a (
{
freeStack(stack); //at this point we are done using the stack
return WARN_MISSING_LPAREN; //return error
}
pop(stack); //POP and get rid of (
}
/************************** convertSubTaskOperand *******************************
void convertSubTaskOperand(Out out, Element *pElement)
Purpose:
This function handles the case of an operand token.
The operand element simply gets added to the out.
Parameters:
O Out out The out structure used in the conversion.
I Element *pElement The operand element.
Returns:
out parm - the updated out structure.
Notes:
This is a sub task of the query conversion from infix format to
postfix format.
*******************************************************************************/
void convertSubTaskOperand(Out out, Element *pElement)
{
addOut(out, *pElement);
}
