📄 parser.java
字号:
return new CaseToken(null, defaultCode);
}
/***********************************************************************************/
/** parse while(something) { do something } */
/* @param */
/* @param */
/* @return */
private OperandToken parseWhile()
{
// check for "(" (e.g. while(..... )
if(!isExpectedDelimiter(peekNextToken(), '(') )
Errors.throwParserException("while: ERROR missing (");
else
getNextToken();
// get argument inside (...)
OperandToken whileRelation = parseArithExpression(SINGLE);
if(!isExpectedDelimiter(peekNextToken(), ')') )
Errors.throwParserException("While: ERROR missing )");
else
getNextToken();
ErrorLogger.debugLine("Parser: while after relation");
// get commands inside {...}
OperandToken whileCode = parseCommandList();
//if (isExpectedDelimiter(peekNextToken(), ',' ) ||
// isExpectedDelimiter(peekNextToken(), ';' ) )
// getNextToken();
if(isExpectedDelimiter(peekNextToken(), "end") ||
isExpectedDelimiter(peekNextToken(), "endwhile") )
{
getNextToken();
ErrorLogger.debugLine("Parser: while: end");
}
else
Errors.throwParserException(" while error");
// While(..) {...}
return (OperandToken)( new WhileOperatorToken(whileRelation, whileCode));
}
/***********************************************************************************/
/** this method parses for loops */
/* (e.g. for(z=0;z<10;z=z+1) { disp(z); } endfor */
/* @param */
/* @param */
/* @return */
private OperandToken parseFor()
{
OperandToken forInitialisation = null;
OperandToken forRelation = null;
OperandToken forIncrement = null;
//skip the opening bracket
//Token dummy = peekNextToken();
if(isExpectedDelimiter(peekNextToken(), '(') )
{
//skip the opening bracket
getNextToken();
ErrorLogger.debugLine("Parser: for loop");
// get arguments inside (...;...;...)
forInitialisation = parseArithExpression(SINGLE);
ErrorLogger.debugLine("Parser: for: initialisation = " + forInitialisation.toString());
if (!isExpectedDelimiter(peekNextToken(), ';' ))
Errors.throwParserException("For: missing ;");
else
getNextToken();
forRelation = parseArithExpression(SINGLE);
ErrorLogger.debugLine("Parser: for: relation = " + forRelation.toString());
if (!isExpectedDelimiter(peekNextToken(), ';' ))
Errors.throwParserException("For: missing ;");
else
getNextToken();
forIncrement = parseArithExpression(SINGLE);
ErrorLogger.debugLine("Parser: for: increment = " + forIncrement.toString());
if (!isExpectedDelimiter(peekNextToken(), ')' ))
Errors.throwParserException("For: missing )");
else
getNextToken();
}
else
{
// e.g. for i=1:4
// e.g. for i=x
// e.g. for i=[1,3,5]
ErrorLogger.debugLine("Parser: FOR vector for loop");
// get arguments inside for < >, ... (e.g. for x=[1,2,3], ...)
forInitialisation = parseArithExpression(SINGLE); //MATRIX); //SINGLE);
// get rid of the closing , ; \n
// e.g. for i=2:5,
// e.g. for i=2:5;
// e.g. for i=2:5\n
if (!isExpectedDelimiter(peekNextToken(), ';' ) &&
!isExpectedDelimiter(peekNextToken(), ',' ) &&
!isExpectedDelimiter(peekNextToken(), '\n') )
Errors.throwParserException("For: missing ; , \\n");
else
getNextToken();
ErrorLogger.debugLine("ParserFOR" + peekNextToken());
//if (!isExpectedDelimiter(peekNextToken(), ',' ) ||
// !isExpectedDelimiter(peekNextToken(), '\n' ) )
// Errors.throwParserException("For: missing , or \\n");
//else
// getNextToken();
ErrorLogger.debugLine("Parser: for: initialisation = " + forInitialisation.toString());
}
// get commands inside {...}
OperandToken forCode = parseCommandList();
//if (peekNextToken() instanceof DelimiterToken)
// getNextToken();
if(isExpectedDelimiter(peekNextToken(), "end") ||
isExpectedDelimiter(peekNextToken(), "endfor") )
{
getNextToken();
ErrorLogger.debugLine("Parser: for: end");
}
else
Errors.throwParserException(" for error");
ErrorLogger.debugLine("Parser: for: code = "+forCode.toString());
// For(...;...;...) {...}
return new ForOperatorToken(forInitialisation, forRelation, forIncrement, forCode);
}
/***********************************************************************************/
/** this method parses matrices (e.g. a=[1,2,3;4,5,6] or a=[1 2 3]) */
/* @return parsed matrix */
private OperandToken parseMatrix()
{
boolean endLine = false; //
boolean endMatrix = false; //
int x = 0; // x-size of matrix
int y = 1; // y-size of matrix
Stack elements = new Stack(); // stack for elements
Stack rowLength = new Stack(); //
boolean numberB = true; //
boolean singleB = true; //
boolean numberIndicatorB = false; //
boolean singleIndicatorB = false; //
boolean imagIndicatorB = false; //
// remove spaces between "[" and first element (e.g. [ 2,3] -> [2,3]
while (isExpectedDelimiter(peekNextToken(MATRIX), ' '))
getNextToken();
// parse code of matrices (e.g. [1,2,3;4,5,6] or [1 sin(2) 3; 4 5+1 a]
while(!endMatrix)
{
// get next parameter (whitespaces are treated as delimiter, too)
OperandToken nextParameter = parseArithExpression(MATRIX);
numberIndicatorB = false;
singleIndicatorB = false;
// check type of each parameter: some operands need special attention
if (nextParameter instanceof Expression)
{
Expression expr = (Expression)nextParameter;
if (expr.getData() == null)
{
if (expr.getNumberOfChildren() == 1)
{
// there is only one parameter
singleIndicatorB = true;
}
}
}
else if (nextParameter instanceof DoubleNumberToken)
{
// this parameter is a number token
DoubleNumberToken numberT = (DoubleNumberToken)nextParameter;
// check if matrix has imaginary values
if (numberT.getValuesIm() != null)
imagIndicatorB = true;
// Check if this number token is a scalar. Otherwise deal with
// it like a general matrix
if((numberT.getSizeX()==1) && (numberT.getSizeY()==1))
numberIndicatorB = true;
}
if (numberIndicatorB == false)
{
// at least one element of the matrix is NOT a number
numberB = false;
}
if (singleIndicatorB == false)
{
// at least one element is not a single operand
singleB = false;
}
ErrorLogger.debugLine("Parser: para" + nextParameter);
// push parameter onto element stack
if (nextParameter != null)
elements.push(nextParameter);
DelimiterToken t = (DelimiterToken)peekNextToken(MATRIX);
if((t.value == ',') ||
(t.value == ' ') )
{
//this marks the end of a matrix element
ErrorLogger.debugLine("Parser: Matrix ,");
getNextToken(MATRIX);
x++;
}
else if((t.value == ';') ||
(t.value == '\n') ||
(t.value == '\r') )
{
//this marks the end of a row
getNextToken(MATRIX);
x++;
ErrorLogger.debugLine("Parser: Matrix ; length "+x);
rowLength.push(new Integer(x)); // save row length
x=0;
y++; // increment row counter
}
else if(t.value == ']')
{
//this marks the end of the matrix
getNextToken(MATRIX);
x++;
rowLength.push(new Integer(x)); // save row length
ErrorLogger.debugLine("Parser: Matrix y="+y+" x="+x);
endMatrix = true;
}
else
{
Errors.throwParserException(" matrix error");
}
} // end while
// create matrix of correct size
if (numberB)
{
// the parsed matrix is a pure number array
ErrorLogger.debugLine("Parser: matrix pure numbers");
// length of rows must be equal
for (int yy=y-1; yy>=0; yy--)
{
if ( ((Integer)rowLength.pop()).intValue() != x)
Errors.throwParserException(" Matrix: all rows must have the same length");
}
double values[][] = new double[y][x];
double valuesImag[][] = new double[1][1];
if (imagIndicatorB)
valuesImag = new double[y][x];
// fill array with double values from element stack
for (int yy=y-1; yy>=0; yy--)
{
for (int xx=x-1; xx>=0; xx--)
{
DoubleNumberToken n = (DoubleNumberToken)elements.pop();
values[yy][xx] = n.getValueRe();
if (imagIndicatorB)
{
valuesImag[yy][xx] = n.getValueIm();
}
}
}
if (!imagIndicatorB)
return (OperandToken)(new DoubleNumberToken(values));
else
return (OperandToken)(new DoubleNumberToken(values, valuesImag));
}
else if (singleB)
{
// pure operands (e.g. variables..., [a,b,c])
ErrorLogger.debugLine("Parser: matrix pure operands");
OperandToken values[][] = new OperandToken[y][x];
// fill array with operands from element stack
for (int yy=y-1; yy>=0; yy--)
{
// row length may vary, e.g. a=[b;c,d]
x = ((Integer)rowLength.pop()).intValue();
values[yy] = new OperandToken[x];
for (i⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -