static ParserObjectAttrT* parseAttr(ParserObjectRecordT* curSeq)
{
ParserObjectAttrT* res;
int i, j, k;
if (!curToken || curToken->type != ttAttrName) return 0;
res = AllocateBuffer(sizeof(ParserObjectAttrT));
memset(res,0,sizeof(ParserObjectAttrT));
res->attrName = AllocateBuffer(strlen(curToken->str) + 1);
strcpy(res->attrName, curToken->str);
moveToNextToken();
if (!chkCurToken('=')) {attrDestructor(res); return 0;}
moveToNextToken();
i = attrFind(res->attrName);
if (i < 0) {
genParseError(E_UNKNOWN_ATTRIBUTE);
attrDestructor(res);
return NULL;
}
if (!curToken) return NULL;
switch (g_ParserObjectKind2AttrValueKind[i]) {
case PARSER_OBJECT_ATTR_VALUE_IDENTIFIER:
res->strVal = parseSingleToken(ttIdentifier);
if (!res->strVal) {attrDestructor(res); return NULL;}
break;
case PARSER_OBJECT_ATTR_VALUE_INTEGER:
res->exVal1 = parseExpression(curSeq);
if (!res->exVal1) {attrDestructor(res); return NULL;}
break;
case PARSER_OBJECT_ATTR_VALUE_INTEGER_RANGE:
parseIntRange(&res->exVal1, &res->exVal2, curSeq);
if (!res->exVal1) {attrDestructor(res); return NULL;}
break;
case PARSER_OBJECT_ATTR_VALUE_CHARSET:
res->strVal = parseSingleToken(ttCharSet);
if (!res->strVal) {attrDestructor(res); return NULL;}
if (isInCharSet(0, res->strVal) < 0) {
genParseError(E_INVALID_CHARSET);
attrDestructor(res); return NULL;
}
res->charNum = 0;
memset(res->valid, 0, sizeof(res->valid));
for (j = 0; j < charNumber; j++) {
res->valid[j] = isInCharSet(j, res->strVal);
if (res->valid[j]) res->charNum++;
}
res->charSetStr = AllocateBuffer(res->charNum+1);
res->charSetStr[res->charNum] = 0; k = 0;
for (j = 0; j < charNumber; j++)
if (res->valid[j]) res->charSetStr[k++] = j;
break;
default:
genParseError(B_ARRAY_ATTR_TYPE_BY_KIND);
attrDestructor(res); return NULL;
}
if (ParserIsErrorRaised()) {attrDestructor(res); return NULL;}
return res;
}
static ParserObjectAttrT* parseAttrList(
ParserObjectKindT objKind,
ParserObjectRecordT* curSeq
)
{
//it should eat semicolons too
ParserObjectAttrT *res = 0;
ParserObjectAttrT *curAttr;
int bad = 0, i, n = 0;
int vis[PARSER_OBJECT_ATTRIBUTE_KINDS_COUNT];
res = AllocateArray(PARSER_OBJECT_ATTRIBUTE_KINDS_COUNT,
sizeof(ParserObjectAttrT));
memset(vis, 0, sizeof(vis));
while ((curAttr = parseAttr(curSeq))) {
i = attrFind(curAttr->attrName);
if (vis[i]) {
genParseError(E_ATTRIBUTE_ALREADY_DEFINED);
attrDestructor(curAttr); curAttr = 0;
bad = 1; break;
}
if (!g_ParserObjectAttrKindIsValidForObjectKind[objKind][i]) {
genParseError(E_INVALID_ATTRIBUTE);
attrDestructor(curAttr); curAttr = 0;
bad = 1; break;
}
vis[i] = 1; n++;
copyAttrToAttr(&(res[i]), curAttr);
attrDestructor(curAttr);
if (chkCurToken(',')) {
bad = 1; moveToNextToken();
} else bad = 0;
}
if (ParserIsErrorRaised()) {attrListDestructor(res); return NULL;}
if (n < getAttrCount(objKind)) bad = 1;
if (bad) {
attrListDestructor(res);
genParseError(E_INVALID_ATTRIBUTE_LIST);
return NULL;
}
if (!curToken || chkCurToken(';')) {
if (curToken) moveToNextToken();
return res;
} else {attrListDestructor(res); return NULL;}
}
//-----------------------------initialize & finalize --------------------------
void initialize(const char* buf1)
{
lastError = 0;
buf = buf1;
bufPos = pos = 0; line = 1;
bufSize = strlen(buf);
moveToNextToken();
}
static void parseIntRange(struct expr** ex1, struct expr** ex2, ParserObjectRecordT* curSeq)
{
if (chkCurToken('[')) {
moveToNextToken();
*ex1 = parseExpression(curSeq);
if (!*ex1 || !chkCurToken(',')) {
exprDestructor(*ex1); *ex1 = *ex2 = 0; return;
}
moveToNextToken();
*ex2 = parseExpression(curSeq);
if (!*ex2 || !chkCurToken(']')) {
exprDestructor(*ex1); exprDestructor(*ex2);
*ex1 = *ex2 = 0; return;
}
moveToNextToken();
} else {
*ex1 = parseExpression(curSeq); *ex2 = 0;
}
}
static char* parseSingleToken(int tokenType)
{
char* res = NULL;
if (curToken && curToken->type == tokenType) {
res = AllocateBuffer(strlen(curToken->str) + 1);
strcpy(res, curToken->str);
moveToNextToken();
} else {
genParseError(E_UNEXPECTED_TOKEN);
}
return res;
}
static ParserObjectT* parseNextObject(ParserObjectRecordT* curSeq)
{
ParserObjectKindT objKind;
ParserObjectT* res;
ParserObjectAttrT* attrList;
char* name;
ParserObjectRecordWithDataT tmp;
if (!curToken) return NULL;
if (curToken->type != ttObject) {
genParseError(E_OBJECT_KIND_EXPECTED);
return NULL;
}
objKind = curToken->value;
moveToNextToken();
attrList = parseAttrList(objKind, curSeq);
if (attrList) {
name = attrList[PARSER_OBJECT_ATTR_NAME].strVal;
if (name) { // if name doesn't exist, than it's unnamed objKind
tmp.pointerToData = 0; tmp.recPart = curSeq;
if (ParserFindObject(name, tmp, 0).objPart) {
genParseError(E_DUPLICATE_OBJECT);
attrListDestructor(attrList);
return NULL;
}
}
}
if (attrList ||
objKind == PARSER_OBJECT_KIND_END ||
objKind == PARSER_OBJECT_KIND_NEWLINE ||
objKind == PARSER_OBJECT_KIND_SOFTLINE)
{
res = AllocateBuffer(sizeof(ParserObjectT));
res->attrList = attrList; res->objKind = objKind;
if (objKind == PARSER_OBJECT_KIND_SEQUENCE) {
res->rec = parseObjRecord1(curSeq);
if (!res->rec) {objDestructor(res); return 0;}
} else res->rec = 0;
if (ParserIsErrorRaised()) {objDestructor(res); return 0;}
//res->parent = curSeq; <- curSeq will reallocate anyway
return res;
}
genParseError(E_INVALID_ATTRIBUTE_LIST);
return NULL;
}
void ScCodeEditor::keyPressEvent( QKeyEvent *e )
{
hideMouseCursor(e);
QTextCursor cursor( textCursor() );
bool cursorMoved = true;
if (e == QKeySequence::MoveToNextWord)
moveToNextToken( cursor, QTextCursor::MoveAnchor );
else if (e == QKeySequence::MoveToPreviousWord)
moveToPreviousToken( cursor, QTextCursor::MoveAnchor );
else if (e == QKeySequence::SelectNextWord)
moveToNextToken( cursor, QTextCursor::KeepAnchor );
else if (e == QKeySequence::SelectPreviousWord)
moveToPreviousToken( cursor, QTextCursor::KeepAnchor );
else
cursorMoved = false;
if (cursorMoved) {
setTextCursor( cursor );
return;
}
switch (e->key()) {
case Qt::Key_Home:
{
Qt::KeyboardModifiers mods(e->modifiers());
if (mods && mods != Qt::ShiftModifier) {
GenericCodeEditor::keyPressEvent(e);
return;
}
QTextCursor::MoveMode mode =
mods & Qt::ShiftModifier ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor;
QTextCursor c(textCursor());
QTextBlock b(c.block());
int pos = indentedStartOfLine(b);
pos += b.position();
if (c.position() == pos)
c.movePosition(QTextCursor::StartOfLine, mode);
else
c.setPosition(pos, mode);
setTextCursor(c);
return;
}
case Qt::Key_Backtab:
{
QTextCursor cursor = textCursor();
insertSpaceToNextTabStop( cursor );
ensureCursorVisible();
return;
}
case Qt::Key_Backspace:
if (mInsertMatchingTokens && !overwriteMode() && e->modifiers() == 0)
if (removeMatchingTokens())
break;
GenericCodeEditor::keyPressEvent(e);
break;
case Qt::Key_Enter:
case Qt::Key_Return:
{
QTextBlock cursorBlock = cursor.block();
int cursorPosInBlock = cursor.position() - cursorBlock.position();
TokenIterator nextToken = TokenIterator::rightOf(cursorBlock, cursorPosInBlock);
if ( nextToken.block() == cursorBlock && nextToken.type() == Token::ClosingBracket )
{
cursor.beginEditBlock();
cursor.insertBlock();
cursor.insertBlock();
cursor.endEditBlock();
cursor.movePosition( QTextCursor::PreviousBlock, QTextCursor::KeepAnchor );
indent(cursor, JoinEditBlock);
cursor.movePosition( QTextCursor::EndOfBlock );
}
else {
cursor.beginEditBlock();
cursor.insertBlock();
cursor.endEditBlock();
indent(cursor, JoinEditBlock);
}
cursor.setVerticalMovementX(-1);
setTextCursor(cursor);
break;
}
default:
if (!overwriteMode() && insertMatchingTokens(e->text()))
break;
GenericCodeEditor::keyPressEvent(e);
}
mAutoCompleter->keyPress(e);
}
static struct expr* parseExpression1(int priority, int isFirst,
ParserObjectRecordT* curSeq)
{
struct expr *res, *op;
ParserObjectT* varObj;
ParserObjectRecordWithDataT tmp;
char ch;
if (priority > priorityNumber) {
switch (curToken->type) {
case ttIdentifier:
res = AllocateBuffer(sizeof(struct expr));
res->op1 = res->op2 = 0; res->opCode = 0;
res->varName = AllocateBuffer(strlen(curToken->str) + 1);
strcpy(res->varName, curToken->str);
tmp.pointerToData = 0; tmp.recPart = curSeq;
varObj = ParserFindObject(res->varName, tmp, 1).objPart;
if (!varObj) genParseError(E_UNKNOWN_OBJECT);
if (!ParserIsErrorRaised() && varObj->objKind != PARSER_OBJECT_KIND_INTEGER) genParseError(E_INTEGER_OBJECT_EXPECTED);
if (ParserIsErrorRaised()) {exprDestructor(res); return 0;}
moveToNextToken();
if (ParserIsErrorRaised()) {exprDestructor(res); return 0;}
return res;
case ttInteger:
res = AllocateBuffer(sizeof(struct expr));
res->op1 = res->op2 = 0; res->opCode = 0; res->varName = 0;
res->intConst = curToken->value;
moveToNextToken();
if (ParserIsErrorRaised()) {exprDestructor(res); return 0;}
return res;
case ttDelim:
if (curToken->value == '(') {
moveToNextToken();
res = parseExpression1(1, 1, curSeq);
if (res && !chkCurToken(')')) {
genParseError(E_RB_EXPECTED);
exprDestructor(res);
return NULL;
}
moveToNextToken();
return res;
}
// don't need "break" here
default:
return NULL;
}
} else {
op = parseExpression1(priority + 1, 1, curSeq);
if (ParserIsErrorRaised()) {exprDestructor(op); return NULL;}
if (!op) {
if (priority == getOpPriority('+') && isFirst &&
(chkCurToken('+') || chkCurToken('-'))) { // unary operations
op = AllocateBuffer(sizeof(struct expr));
op->op1 = op->op2 = 0; op->opCode = 0; op->varName = 0;
op->intConst = 0;
} else {
if (priority == getOpPriority('+')) {
genParseError(E_OPERAND_EXPECTED);
}
return NULL;
}
}
if (chkCurToken('^')) {
if (priority < getOpPriority('^')) {
genParseError(B_UNEXPECTED_CAP);
exprDestructor(op);
return NULL;
}
res = AllocateBuffer(sizeof(struct expr));
res->op1 = op; res->opCode = '^';
res->varName = 0; res->intConst = 0;
moveToNextToken();
res->op2 = parseExpression1(priority, 0, curSeq);
if (!res->op2) {exprDestructor(res->op2); return NULL;}
op = res;
} else {
while ((chkCurToken('+') || chkCurToken('-') ||
chkCurToken('*') || chkCurToken('/')) &&
getOpPriority((int)curToken->value) == priority) {
ch = (char)curToken->value;
res = AllocateBuffer(sizeof(struct expr));
res->op1 = op; res->opCode = ch;
res->varName = 0; res->intConst = 0;
moveToNextToken();
res->op2 = parseExpression1(priority, 0, curSeq);
if (!res->op2) {exprDestructor(res); return NULL;}
op = res;
}
}
if (ParserIsErrorRaised()) {exprDestructor(op); return NULL;}
return op;
}
}
void ScCodeEditor::keyPressEvent( QKeyEvent *e )
{
QTextCursor cursor( textCursor() );
bool cursorMoved = true;
if (e == QKeySequence::MoveToNextWord)
moveToNextToken( cursor, QTextCursor::MoveAnchor );
else if (e == QKeySequence::MoveToPreviousWord)
moveToPreviousToken( cursor, QTextCursor::MoveAnchor );
else if (e == QKeySequence::SelectNextWord)
moveToNextToken( cursor, QTextCursor::KeepAnchor );
else if (e == QKeySequence::SelectPreviousWord)
moveToPreviousToken( cursor, QTextCursor::KeepAnchor );
else
cursorMoved = false;
if (cursorMoved) {
setTextCursor( cursor );
return;
}
switch (e->key()) {
case Qt::Key_Home:
{
Qt::KeyboardModifiers mods(e->modifiers());
if (mods && mods != Qt::ShiftModifier) {
GenericCodeEditor::keyPressEvent(e);
return;
}
hideMouseCursor();
QTextCursor::MoveMode mode =
mods & Qt::ShiftModifier ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor;
QTextCursor c(textCursor());
QTextBlock b(c.block());
int pos = indentedStartOfLine(b);
pos += b.position();
if (c.position() == pos)
c.movePosition(QTextCursor::StartOfLine, mode);
else
c.setPosition(pos, mode);
setTextCursor(c);
return;
}
case Qt::Key_Backtab:
{
hideMouseCursor();
QTextCursor cursor = textCursor();
insertSpaceToNextTabStop( cursor );
ensureCursorVisible();
return;
}
default:
{
static const QString closingBrackets(")]}");
bool indentCurrentLine =
e->key() == Qt::Key_Enter ||
e->key() == Qt::Key_Return ||
( !e->text().isEmpty() && closingBrackets.contains(e->text()) );
if (indentCurrentLine)
cursor.beginEditBlock();
GenericCodeEditor::keyPressEvent(e);
if (indentCurrentLine) {
cursor.endEditBlock();
cursor.joinPreviousEditBlock();
indent();
cursor.endEditBlock();
}
}
}
mAutoCompleter->keyPress(e);
}
void ScCodeEditor::keyPressEvent( QKeyEvent *e )
{
QTextCursor cursor( textCursor() );
bool cursorMoved = true;
if (e == QKeySequence::MoveToNextWord)
moveToNextToken( cursor, QTextCursor::MoveAnchor );
else if (e == QKeySequence::MoveToPreviousWord)
moveToPreviousToken( cursor, QTextCursor::MoveAnchor );
else if (e == QKeySequence::SelectNextWord)
moveToNextToken( cursor, QTextCursor::KeepAnchor );
else if (e == QKeySequence::SelectPreviousWord)
moveToPreviousToken( cursor, QTextCursor::KeepAnchor );
else
cursorMoved = false;
if (cursorMoved) {
setTextCursor( cursor );
return;
}
switch (e->key()) {
case Qt::Key_Home:
{
Qt::KeyboardModifiers mods(e->modifiers());
if (mods && mods != Qt::ShiftModifier) {
GenericCodeEditor::keyPressEvent(e);
return;
}
hideMouseCursor();
QTextCursor::MoveMode mode =
mods & Qt::ShiftModifier ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor;
QTextCursor c(textCursor());
QTextBlock b(c.block());
int pos = indentedStartOfLine(b);
pos += b.position();
if (c.position() == pos)
c.movePosition(QTextCursor::StartOfLine, mode);
else
c.setPosition(pos, mode);
setTextCursor(c);
return;
}
case Qt::Key_Backtab:
{
hideMouseCursor();
QTextCursor cursor = textCursor();
insertSpaceToNextTabStop( cursor );
ensureCursorVisible();
return;
}
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_BraceRight:
case Qt::Key_BracketRight:
case Qt::Key_ParenRight: {
hideMouseCursor();
// Wrap superclass' implementation into an edit block,
// so it can be joined with indentation later:
QTextCursor cursor = textCursor();
cursor.beginEditBlock();
GenericCodeEditor::keyPressEvent(e);
cursor.endEditBlock();
cursor.joinPreviousEditBlock();
indent();
cursor.endEditBlock();
cursor.setVerticalMovementX(-1);
setTextCursor(cursor);
break;
}
default:
GenericCodeEditor::keyPressEvent(e);
}
mAutoCompleter->keyPress(e);
}
time_t parseDuration(const char *string) {
/*
* Allowed format:
* jj hh:mn:ss
* hh:mn:ss
* nn
* nn s
* nn mn
* nn h
* nn j
*/
durationParserStates state = init;
time_t duration = 0;
register const char *cursor = string;
unsigned int n;
while(*cursor != '\0') {
cursor = parseInteger(cursor,&n);
cursor = moveToNextToken(cursor);
switch(*cursor) {
case '\0':
duration = duration * 60 + n;
break;
case 's':
duration += n;
cursor++;
break;
case 'm':
cursor++;
if ('n' == *cursor) {
duration += n*60;
cursor++;
} else {
WARNING_MSG("unknow time unit at m%s", cursor);
duration = 0;
cursor = moveToEnd(cursor);
}
break;
case 'h':
duration += n*3600;
cursor++;
break;
case 'j':
duration += n*24*3600;
cursor++;
break;
case ':':
/* hh:mn:ss */
switch(state) {
case init:
duration = n;
state = hours; /* hours read */
break;
case days:
duration = duration * 24 + n;
state = hours; /* hours read */
break;
case hours:
duration = duration * 60 + n;
state = minutes; /* minutes read */
break;
case minutes:
duration = (duration + n) * 60;
state = seconds; /* seconds read */
case seconds:
WARNING_MSG("bad string time format %s",string);
duration = 0;
cursor = moveToEnd(cursor) - 1;
break;
} /* switch(state) */
cursor++;
break;
default:
if (isdigit(*cursor)) {
/* jj hh:mn:ss */
state = days; /* days read */
duration = n;
} else {
WARNING_MSG("bad string format %s",string);
duration = 0;
cursor = moveToEnd(cursor) - 1;
}
} /* switch(*cursor) */
} /*(cursor != '\0')*/
return duration;
}
