bool parse(const char * const name, __Matrix &matrix)
{
std::vector<double> row;
matrix.clear();
if (_fd == nullptr)
_fd = fopen(name, "r");
if (_fd == nullptr)
return false;
next();
while (!eof()) {
_buffer.clear();
parseNumber();
if (_buffer.size() > 0) {
row.push_back(atof(_buffer.c_str()));
}
if (isEndOfLine()) {
skipEndOfLine();
matrix.push_back(row);
row.clear();
}
}
if (row.size() > 0)
matrix.push_back(row);
fclose(_fd);
_fd = nullptr;
return true;
}
/*----------------------------------------------------------------------------*/
int checkOneOperands(Data * data, char * tag){
char operand[MAX_TAG_LEN];
if(sscanf(data->line, "%30s", operand) == 0){
printf("[Error] on line %d: no operands given - one operand required\n", data->lc);
data->containError=TRUE;
return 0;
}
data->line+= strlen(operand);
eatSpace(data);
/* shouldn't be any additional character or arguments after the operand */
if(isEndOfLine(data->line) == 0){
printf("[Error] on line %d: extra argument or characters after the operand \n", data->lc);
data->containError=TRUE;
return 0;
}
if (isOperandValidSyntax(data,operand) == 0){
printf("[Error] on line %d: operand is invalid \n", data->lc);
data->containError=TRUE;
return 0;
}
/* what happens when IC and DC are the same? how does it diffrentiate address? is DC limited to 100? */
if(tag != NULL){
addTag(data,tag,data->ic);
}
data->ic+=2;
return 1;
}
/**
This is not a really definitive search.
Should be replaced with something better
*/
static bool
findEncryptObject(FILE *file, const int e_pos, EncData *e) {
int ch;
/** only find the encrypt object if e_pos > -1 */
if(e_pos < 0)
return false;
ch = getc(file);
while(ch != EOF) {
if(isEndOfLine(ch)) {
if(parseInt(file) == e_pos) {
ch = parseWhiteSpace(file);
if(ch >= '0' && ch <= '9') {
ch = parseWhiteSpace(file);
if(ch == 'o' && getc(file) == 'b' && getc(file) == 'j' &&
parseWhiteSpace(file) == '<' && getc(file) == '<') {
return parseEncrypObject(file, e);
}
}
}
}
ch = getc(file);
}
return false;
}
std::vector<std::vector<Type>> parse(const char * const name) {
std::vector<std::vector<Type>> matrix;
matrix.clear();
std::vector<Type> row;
if (_fd == nullptr)
_fd = fopen(name, "r");
if (_fd == nullptr)
return matrix;
next();
while (!eof()) {
_buffer.clear();
parseNumber();
if (_buffer.size() > 0) {
row.push_back(atof(_buffer.c_str()));
}
if (isEndOfLine()) {
skipEndOfLine();
matrix.push_back(row);
row.clear();
}
}
if (row.size() > 0)
matrix.push_back(row);
fclose(_fd);
_fd = nullptr;
return matrix;
}
/*----------------------------------------------------------------------------*/
int checkTwoOperands(Data * data, char * tag,char* command){
char operand1[MAX_TAG_LEN];
char operand2[MAX_TAG_LEN];
/* get the 1st operand*/
if(sscanf(data->line, "%30[^,\n ]s", operand1) == 0){
printf("[Error] on line %d: no operands given - two operands required\n", data->lc);
data->containError=TRUE;
return 0;
}
/* check there's a comma between the two operands */
data->line+= strlen(operand1);
eatSpace(data);
if(!(*data->line)==','){
printf("[Error] on line %d: no comma between operands\n", data->lc);
data->containError=TRUE;
return 0;
}
data->line++;
/* get the 2nd operand*/
if(sscanf(data->line, "%30s", operand2) == 0){
printf("[Error] on line %d: second operand required\n", data->lc);
data->containError=TRUE;
return 0;
}
data->line+= strlen(operand2);
/* add a terminating character to the operand string */
eatSpace(data);
/* shouldn't be any additional character or arguments after the 2nd operand */
if(isEndOfLine(data->line) == 0){
printf("[Error] on line %d: extra characters after 2nd operand \n", data->lc);
data->containError=TRUE;
return 0;
}
/* check the first operand is valid syntactically */
if (isOperandValidSyntax(data,operand1) == 0){
printf("[Error] on line %d: first operand is invalid \n", data->lc);
data->containError=TRUE;
return 0;
}
/* check the second operand is valid syntactically */
if (isOperandValidSyntax(data,operand2) == 0){
printf("[Error] on line %d: second operand is invalid \n", data->lc);
data->containError=TRUE;
return 0;
}
/* add the address under the tag if it was given */
if(tag != NULL){
addTag(data,tag,data->ic);
}
data->ic+=3;
return 1;
}
void getNextToken(Lexer *self) {
self->startPos = 0;
skipLayoutAndComments(self);
self->startPos = self->pos;
if (isEndOfInput(self->currentChar)) {
recognizeEndOfInputToken(self);
self->running = false; // stop lexing
return;
}
else if (isDigit(self->currentChar) || (self->currentChar == '.' && isDigit(peekAhead(self, 1)))) {
// number
recognizeNumberToken(self);
}
else if (isLetterOrDigit(self->currentChar) || self->currentChar == '_') {
// ident
recognizeIdentifierToken(self);
}
else if (isString(self->currentChar)) {
// string
recognizeStringToken(self);
}
else if (isCharacter(self->currentChar)) {
// character
recognizeCharacterToken(self);
}
else if (isOperator(self->currentChar)) {
// operator
recognizeOperatorToken(self);
}
else if (isEndOfLine(self->currentChar)) {
recognizeEndOfLineToken(self);
}
else if (isSeparator(self->currentChar)) {
// separator
recognizeSeparatorToken(self);
}
else {
// errorneous
recognizeErroneousToken(self);
}
}
void VisibleSelection::setStartAndEndFromBaseAndExtentRespectingGranularity(TextGranularity granularity)
{
if (m_baseIsFirst) {
m_start = m_base;
m_end = m_extent;
} else {
m_start = m_extent;
m_end = m_base;
}
switch (granularity) {
case CharacterGranularity:
// Don't do any expansion.
break;
case WordGranularity: {
// General case: Select the word the caret is positioned inside of, or at the start of (RightWordIfOnBoundary).
// Edge case: If the caret is after the last word in a soft-wrapped line or the last word in
// the document, select that last word (LeftWordIfOnBoundary).
// Edge case: If the caret is after the last word in a paragraph, select from the the end of the
// last word to the line break (also RightWordIfOnBoundary);
VisiblePosition start = VisiblePosition(m_start, m_affinity);
VisiblePosition originalEnd(m_end, m_affinity);
EWordSide side = RightWordIfOnBoundary;
if (isEndOfEditableOrNonEditableContent(start) || (isEndOfLine(start) && !isStartOfLine(start) && !isEndOfParagraph(start)))
side = LeftWordIfOnBoundary;
m_start = startOfWord(start, side).deepEquivalent();
side = RightWordIfOnBoundary;
if (isEndOfEditableOrNonEditableContent(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd) && !isEndOfParagraph(originalEnd)))
side = LeftWordIfOnBoundary;
VisiblePosition wordEnd(endOfWord(originalEnd, side));
VisiblePosition end(wordEnd);
if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.deprecatedNode())) {
// Select the paragraph break (the space from the end of a paragraph to the start of
// the next one) to match TextEdit.
end = wordEnd.next();
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table.
if (isBlock(table))
end = end.next(CannotCrossEditingBoundary);
else
end = wordEnd;
}
if (end.isNull())
end = wordEnd;
}
m_end = end.deepEquivalent();
// End must not be before start.
if (m_start.deprecatedNode() == m_end.deprecatedNode() && m_start.deprecatedEditingOffset() > m_end.deprecatedEditingOffset()) {
Position swap(m_start);
m_start = m_end;
m_end = swap;
}
break;
}
case SentenceGranularity: {
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
}
case LineGranularity: {
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
VisiblePosition end = endOfLine(VisiblePosition(m_end, m_affinity));
// If the end of this line is at the end of a paragraph, include the space
// after the end of the line in the selection.
if (isEndOfParagraph(end)) {
VisiblePosition next = end.next();
if (next.isNotNull())
end = next;
}
m_end = end.deepEquivalent();
break;
}
case LineBoundary:
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfLine(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphGranularity: {
VisiblePosition pos(m_start, m_affinity);
if (isStartOfLine(pos) && isEndOfEditableOrNonEditableContent(pos))
pos = pos.previous();
m_start = startOfParagraph(pos).deepEquivalent();
VisiblePosition visibleParagraphEnd = endOfParagraph(VisiblePosition(m_end, m_affinity));
// Include the "paragraph break" (the space from the end of this paragraph to the start
// of the next one) in the selection.
VisiblePosition end(visibleParagraphEnd.next());
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table, not at the position just after the table.
if (isBlock(table))
end = end.next(CannotCrossEditingBoundary);
// There is no parargraph break after the last paragraph in the last cell of an inline table.
else
end = visibleParagraphEnd;
}
if (end.isNull())
end = visibleParagraphEnd;
m_end = end.deepEquivalent();
break;
}
case DocumentBoundary:
m_start = startOfDocument(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfDocument(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphBoundary:
m_start = startOfParagraph(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfParagraph(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case SentenceBoundary:
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case DocumentGranularity:
ASSERT_NOT_REACHED();
break;
}
// Make sure we do not have a dangling start or end.
if (m_start.isNull())
m_start = m_end;
if (m_end.isNull())
m_end = m_start;
}
void VisibleSelection::setStartAndEndFromBaseAndExtentRespectingGranularity(TextGranularity granularity)
{
if (m_baseIsFirst) {
m_start = m_base;
m_end = m_extent;
} else {
m_start = m_extent;
m_end = m_base;
}
switch (granularity) {
case CharacterGranularity:
// Don't do any expansion.
break;
case WordGranularity: {
// General case: Select the word the caret is positioned inside of, or at the start of (RightWordIfOnBoundary).
// Edge case: If the caret is after the last word in a soft-wrapped line or the last word in
// the document, select that last word (LeftWordIfOnBoundary).
// Edge case: If the caret is after the last word in a paragraph, select from the the end of the
// last word to the line break (also RightWordIfOnBoundary);
VisiblePosition start = VisiblePosition(m_start, m_affinity);
VisiblePosition originalEnd(m_end, m_affinity);
EWordSide side = RightWordIfOnBoundary;
//SAMSUNG - Text Selection >>
Document *doc = NULL;
if (m_start.anchorNode())
doc = m_start.anchorNode()->document();
if (doc && doc->settings() && doc->settings()->advancedSelectionEnabled())
{
bool endOfDocument;
if ( (endOfDocument = isEndOfDocument(start)) || ( (isEndOfLine(start) || isStartOfSpace(start)) && !isStartOfLine(start)))
{
side = LeftWordIfOnBoundary;
if (!endOfDocument && isEndOfParagraph(start))
{
originalEnd = start;
}
}
m_start = startOfWord(start, side).deepEquivalent();
side = RightWordIfOnBoundary;
if (isStartOfSpace(start))
{
side = LeftWordIfOnBoundary;
}
if (isEndOfDocument(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd)))
side = LeftWordIfOnBoundary;
VisiblePosition wordEnd(endOfWord(originalEnd, side));
VisiblePosition end(wordEnd);
m_end = end.deepEquivalent();
}
else
{
//SAMSUNG - Text Selection <<
if (isEndOfDocument(start) || (isEndOfLine(start) && !isStartOfLine(start) && !isEndOfParagraph(start)))
side = LeftWordIfOnBoundary;
m_start = startOfWord(start, side).deepEquivalent();
side = RightWordIfOnBoundary;
if (isEndOfDocument(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd) && !isEndOfParagraph(originalEnd)))
side = LeftWordIfOnBoundary;
VisiblePosition wordEnd(endOfWord(originalEnd, side));
VisiblePosition end(wordEnd);
if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.deprecatedNode())) {
// Select the paragraph break (the space from the end of a paragraph to the start of
// the next one) to match TextEdit.
end = wordEnd.next();
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table.
if (isBlock(table))
end = end.next(CannotCrossEditingBoundary);
else
end = wordEnd;
}
if (end.isNull())
end = wordEnd;
}
m_end = end.deepEquivalent();
//SAMSUNG - Text Selection >>
}
//SAMSUNG - Text Selection <<
break;
}
case SentenceGranularity: {
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
}
case LineGranularity: {
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
VisiblePosition end = endOfLine(VisiblePosition(m_end, m_affinity));
// If the end of this line is at the end of a paragraph, include the space
// after the end of the line in the selection.
if (isEndOfParagraph(end)) {
VisiblePosition next = end.next();
if (next.isNotNull())
end = next;
}
m_end = end.deepEquivalent();
break;
}
case LineBoundary:
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfLine(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphGranularity: {
VisiblePosition pos(m_start, m_affinity);
if (isStartOfLine(pos) && isEndOfDocument(pos))
pos = pos.previous();
m_start = startOfParagraph(pos).deepEquivalent();
VisiblePosition visibleParagraphEnd = endOfParagraph(VisiblePosition(m_end, m_affinity));
// Include the "paragraph break" (the space from the end of this paragraph to the start
// of the next one) in the selection.
//SAMSUNG - Text Selection >>
// Here it tries to extend the end point from current paragraph to beginning of next paragraph. So somehow it is
// selecting the next paragraph also and it looks wrong when we do backward paragraph selection.
// Even though user is trying to extend selection in backward direction, because of this condition it extends selection
// in both directions. So commented the below code to avoid wrong backward text selection
// WAS: VisiblePosition end(visibleParagraphEnd.next());
VisiblePosition end(visibleParagraphEnd);
//SAMSUNG - Text Selection <<
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table, not at the position just after the table.
if (isBlock(table))
end = end.next(CannotCrossEditingBoundary);
// There is no parargraph break after the last paragraph in the last cell of an inline table.
else
end = visibleParagraphEnd;
}
if (end.isNull())
end = visibleParagraphEnd;
m_end = end.deepEquivalent();
break;
}
case DocumentBoundary:
m_start = startOfDocument(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfDocument(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphBoundary:
m_start = startOfParagraph(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfParagraph(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case SentenceBoundary:
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case WebKitVisualWordGranularity:
break;
}
// Make sure we do not have a dangling start or end.
if (m_start.isNull())
m_start = m_end;
if (m_end.isNull())
m_end = m_start;
}
void skipEndOfLine()
{
while (!eof() && isEndOfLine() && next());
}
/**
* Ad hoc lexical analyzer to divide command line into tokens
* @param *line pointer to line to parse
* @param linelen length of line to parse
* @param *tokbuf buffer for tokens
* @param *tok[] array of pointers into token buffer
* @return number of tokens created
*/
short lexan(char *line, ushort linelen, char *tokbuf, char *tok[])
{
char quote; /* character for quoted string */
ushort ntok = 0; /* number of tokens parsed */
ushort i = 0; /* temp variable */
while ((i < linelen) && (ntok < SHELL_MAXTOK))
{
/* Skip whitespace in line of input */
while (isWhitespace(line[i]) && (i < linelen))
{
i++;
}
/* Stop parsing at end of line */
if (isEndOfLine(line[i]) || (i >= linelen))
{
return ntok;
}
/* Set token to point to value in token buffer */
tok[ntok] = tokbuf;
/* Handle quoted string */
if (isQuote(line[i]))
{
quote = *tokbuf++ = line[i++];
while ((quote != line[i])
&& (!isEndOfLine(line[i])) && (i < linelen))
{
*tokbuf++ = line[i++];
}
if (quote == line[i])
{
*tokbuf++ = line[i++];
}
else
{
return SYSERR;
}
}
else
{
*tokbuf++ = line[i++];
/* Handle standard alphanumeric token */
if (!isOtherSpecial(line[i - 1]))
{
while ((!isEndOfLine(line[i])) && (!isQuote(line[i]))
&& (!isOtherSpecial(line[i]))
&& (!isWhitespace(line[i])) && (i < linelen))
{
*tokbuf++ = line[i++];
}
if (i >= linelen)
return SYSERR;
}
}
/* Finish current token */
*tokbuf++ = '\0';
ntok++;
}
return ntok;
}
void Selection::validate()
{
// Move the selection to rendered positions, if possible.
bool baseAndExtentEqual = m_base == m_extent;
if (m_base.isNotNull()) {
m_base = VisiblePosition(m_base, m_affinity).deepEquivalent();
if (baseAndExtentEqual)
m_extent = m_base;
}
if (m_extent.isNotNull() && !baseAndExtentEqual)
m_extent = VisiblePosition(m_extent, m_affinity).deepEquivalent();
// Make sure we do not have a dangling base or extent.
if (m_base.isNull() && m_extent.isNull())
m_baseIsFirst = true;
else if (m_base.isNull()) {
m_base = m_extent;
m_baseIsFirst = true;
} else if (m_extent.isNull()) {
m_extent = m_base;
m_baseIsFirst = true;
} else {
m_baseIsFirst = comparePositions(m_base, m_extent) <= 0;
}
if (m_baseIsFirst) {
m_start = m_base;
m_end = m_extent;
} else {
m_start = m_extent;
m_end = m_base;
}
// Expand the selection if requested.
switch (m_granularity) {
case CharacterGranularity:
// Don't do any expansion.
break;
case WordGranularity: {
// General case: Select the word the caret is positioned inside of, or at the start of (RightWordIfOnBoundary).
// Edge case: If the caret is after the last word in a soft-wrapped line or the last word in
// the document, select that last word (LeftWordIfOnBoundary).
// Edge case: If the caret is after the last word in a paragraph, select from the the end of the
// last word to the line break (also RightWordIfOnBoundary);
VisiblePosition start = VisiblePosition(m_start, m_affinity);
VisiblePosition originalEnd(m_end, m_affinity);
EWordSide side = RightWordIfOnBoundary;
if (isEndOfDocument(start) || (isEndOfLine(start) && !isStartOfLine(start) && !isEndOfParagraph(start)))
side = LeftWordIfOnBoundary;
m_start = startOfWord(start, side).deepEquivalent();
side = RightWordIfOnBoundary;
if (isEndOfDocument(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd) && !isEndOfParagraph(originalEnd)))
side = LeftWordIfOnBoundary;
VisiblePosition wordEnd(endOfWord(originalEnd, side));
VisiblePosition end(wordEnd);
if (isEndOfParagraph(originalEnd)) {
// Select the paragraph break (the space from the end of a paragraph to the start of
// the next one) to match TextEdit.
end = wordEnd.next();
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table.
if (isBlock(table))
end = end.next(true);
else
end = wordEnd;
}
if (end.isNull())
end = wordEnd;
}
m_end = end.deepEquivalent();
break;
}
case SentenceGranularity: {
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
}
case LineGranularity: {
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
VisiblePosition end = endOfLine(VisiblePosition(m_end, m_affinity));
// If the end of this line is at the end of a paragraph, include the space
// after the end of the line in the selection.
if (isEndOfParagraph(end)) {
VisiblePosition next = end.next();
if (next.isNotNull())
end = next;
}
m_end = end.deepEquivalent();
break;
}
case LineBoundary:
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfLine(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphGranularity: {
VisiblePosition pos(m_start, m_affinity);
if (isStartOfLine(pos) && isEndOfDocument(pos))
pos = pos.previous();
m_start = startOfParagraph(pos).deepEquivalent();
VisiblePosition visibleParagraphEnd = endOfParagraph(VisiblePosition(m_end, m_affinity));
// Include the "paragraph break" (the space from the end of this paragraph to the start
// of the next one) in the selection.
VisiblePosition end(visibleParagraphEnd.next());
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table, not at the position just after the table.
if (isBlock(table))
end = end.next(true);
// There is no parargraph break after the last paragraph in the last cell of an inline table.
else
end = visibleParagraphEnd;
}
if (end.isNull())
end = visibleParagraphEnd;
m_end = end.deepEquivalent();
break;
}
case DocumentBoundary:
m_start = startOfDocument(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfDocument(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphBoundary:
m_start = startOfParagraph(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfParagraph(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case SentenceBoundary:
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
}
// Make sure we do not have a dangling start or end.
if (m_start.isNull())
m_start = m_end;
if (m_end.isNull())
m_end = m_start;
adjustForEditableContent();
// adjust the state
if (m_start.isNull()) {
ASSERT(m_end.isNull());
m_state = NONE;
// enforce downstream affinity if not caret, as affinity only
// makes sense for caret
m_affinity = DOWNSTREAM;
} else if (m_start == m_end || m_start.upstream() == m_end.upstream()) {
m_state = CARET;
} else {
m_state = RANGE;
// enforce downstream affinity if not caret, as affinity only
// makes sense for caret
m_affinity = DOWNSTREAM;
// "Constrain" the selection to be the smallest equivalent range of nodes.
// This is a somewhat arbitrary choice, but experience shows that it is
// useful to make to make the selection "canonical" (if only for
// purposes of comparing selections). This is an ideal point of the code
// to do this operation, since all selection changes that result in a RANGE
// come through here before anyone uses it.
m_start = m_start.downstream();
m_end = m_end.upstream();
}
}
static int
findTrailer(FILE *file, EncData *e) {
int ch;
/** int pos_i; */
bool encrypt = false;
bool id = false;
int e_pos = -1;
p_str *str = NULL;
ch = getc(file);
while(ch != EOF) {
if(isEndOfLine(ch)) {
if(isWord(file, "trailer")) {
/** printf("found trailer\n");*/
ch = parseWhiteSpace(file);
if(ch == '<' && getc(file) == '<') {
/** we can be pretty sure to have found the trailer.
start looking for the Encrypt-entry */
/**
pos_i = ftell(file);
printf("found Trailer at pos %x\n", pos_i);
*/
ch = getc(file);
while(ch != EOF) {
if(ch == '>') {
ch = getc(file);
if(ch == '>')
break;
}
while(ch != '/' && ch != EOF) {
ch = getc(file);
}
ch = getc(file);
/**printf("found a name: %c\n", ch);*/
if(e_pos < 0 && ch == 'E' && isWord(file, "ncrypt")) {
e_pos = parseIntWithC(file,parseWhiteSpace(file));
if(e_pos >= 0) {
/**
pos_i = ftell(file);
printf("found Encrypt at pos %x, ", pos_i);
printf("%d\n", e_pos);
*/
encrypt = true;
}
}
else if(ch == 'I' && getc(file) == 'D') {
ch = parseWhiteSpace(file);
while(ch != '[' && ch != EOF)
ch = getc(file);
if(str) {
if(str->content)
free(str->content);
free(str);
str = NULL;
}
str = parseRegularString(file);
/**
pos_i = ftell(file);
printf("found ID at pos %x\n", pos_i);
*/
if(str)
id = true;
ch = getc(file);
}
else
ch = getc(file);
if(encrypt && id) {
/**printf("found all, returning: epos: %d\n",e_pos);*/
e->fileID = str->content;
e->fileIDLen = str->len;
free(str);
return e_pos;
}
}
}
}
else {
ch = getc(file);
}
}
else
ch = getc(file);
}
/** printf("finished searching\n");*/
if(str) {
if(str->content)
free(str->content);
free(str);
}
if(!encrypt && id)
return ETRENF;
else if(!id && encrypt)
return ETRINF;
else
return ETRANF;
}
void VisibleSelection::setStartAndEndFromBaseAndExtentRespectingGranularity(TextGranularity granularity)
{
if (m_baseIsFirst) {
m_start = m_base;
m_end = m_extent;
} else {
m_start = m_extent;
m_end = m_base;
}
switch (granularity) {
case CharacterGranularity:
// Don't do any expansion.
break;
case WordGranularity: {
// General case: Select the word the caret is positioned inside of, or at the start of (RightWordIfOnBoundary).
// Edge case: If the caret is after the last word in a soft-wrapped line or the last word in
// the document, select that last word (LeftWordIfOnBoundary).
// Edge case: If the caret is after the last word in a paragraph, select from the the end of the
// last word to the line break (also RightWordIfOnBoundary);
VisiblePosition start = VisiblePosition(m_start, m_affinity);
VisiblePosition originalEnd(m_end, m_affinity);
EWordSide side = RightWordIfOnBoundary;
if (isEndOfDocument(start) || (isEndOfLine(start) && !isStartOfLine(start) && !isEndOfParagraph(start)))
side = LeftWordIfOnBoundary;
m_start = startOfWord(start, side).deepEquivalent();
side = RightWordIfOnBoundary;
if (isEndOfDocument(originalEnd) || (isEndOfLine(originalEnd) && !isStartOfLine(originalEnd) && !isEndOfParagraph(originalEnd)))
side = LeftWordIfOnBoundary;
VisiblePosition wordEnd(endOfWord(originalEnd, side));
VisiblePosition end(wordEnd);
if (isEndOfParagraph(originalEnd) && !isEmptyTableCell(m_start.deprecatedNode())) {
// Select the paragraph break (the space from the end of a paragraph to the start of
// the next one) to match TextEdit.
end = wordEnd.next();
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table.
if (isBlock(table))
end = end.next(CannotCrossEditingBoundary);
else
end = wordEnd;
}
if (end.isNull())
end = wordEnd;
}
m_end = end.deepEquivalent();
//added this to select only letters for dictionary viewing
if( m_selectOnlyLetters && m_start.anchorNode()->isTextNode() && m_end.anchorNode()->isTextNode() ) {
CharacterData* startText = static_cast<CharacterData*>(m_start.anchorNode());
String startStr = startText->data();
CharacterData* endText = static_cast<CharacterData*>(m_end.anchorNode());
String endStr = endText->data();
int n1 = m_start.offsetInContainerNode();
int n2 = m_end.offsetInContainerNode() - 1;
//unhandled corner case: at beginning of sentence, m_start may refer
//to the Node of the last sentence, this causes the space at the beginning
//of a sentence to be part of the selection. Assigning m_end to m_start and
//adjusting the offset does not fix this.
QChar c1 = startStr[n1];
QChar c2 = endStr[n2];
while(!c1.isLetter() && n1 <= n2) {
c1 = startStr[++n1];
m_start = m_start.next(Character);
}
while(!c2.isLetter() && n2 >= n1) {
c2 = endStr[--n2];
m_end = m_end.previous(Character);
}
}
break;
}
case SentenceGranularity: {
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
}
case LineGranularity: {
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
VisiblePosition end = endOfLine(VisiblePosition(m_end, m_affinity));
// If the end of this line is at the end of a paragraph, include the space
// after the end of the line in the selection.
if (isEndOfParagraph(end)) {
VisiblePosition next = end.next();
if (next.isNotNull())
end = next;
}
m_end = end.deepEquivalent();
break;
}
case LineBoundary:
m_start = startOfLine(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfLine(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphGranularity: {
VisiblePosition pos(m_start, m_affinity);
if (isStartOfLine(pos) && isEndOfDocument(pos))
pos = pos.previous();
m_start = startOfParagraph(pos).deepEquivalent();
VisiblePosition visibleParagraphEnd = endOfParagraph(VisiblePosition(m_end, m_affinity));
// Include the "paragraph break" (the space from the end of this paragraph to the start
// of the next one) in the selection.
VisiblePosition end(visibleParagraphEnd.next());
if (Node* table = isFirstPositionAfterTable(end)) {
// The paragraph break after the last paragraph in the last cell of a block table ends
// at the start of the paragraph after the table, not at the position just after the table.
if (isBlock(table))
end = end.next(CannotCrossEditingBoundary);
// There is no parargraph break after the last paragraph in the last cell of an inline table.
else
end = visibleParagraphEnd;
}
if (end.isNull())
end = visibleParagraphEnd;
m_end = end.deepEquivalent();
break;
}
case DocumentBoundary:
m_start = startOfDocument(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfDocument(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case ParagraphBoundary:
m_start = startOfParagraph(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfParagraph(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case SentenceBoundary:
m_start = startOfSentence(VisiblePosition(m_start, m_affinity)).deepEquivalent();
m_end = endOfSentence(VisiblePosition(m_end, m_affinity)).deepEquivalent();
break;
case WebKitVisualWordGranularity:
break;
}
// Make sure we do not have a dangling start or end.
if (m_start.isNull())
m_start = m_end;
if (m_end.isNull())
m_end = m_start;
}
/**
* @brief Builds a kernel-rule out of the given user-rule, and adds it to the kernel rules buffer.
*
* @param kernelRules - out parameter, which will hold the kernel rule.
* @param userRule - the user rule from which the kernel rule should be built. Must end with a newline character.
*
* @return the number of bytes written to the kernelRules buffer, or 0 in case of failure.
*/
int addKernelRuleByUserRule(char * kernelRules, char * userRule, int userRuleNum)
{
/* Variable declarations */
char name[20] = "";
unsigned short direction = 0;
unsigned int srcIp = 0;
unsigned short srcPrefixSize = 0;
unsigned int dstIp = 0;
unsigned short dstPrefixSize = 0;
unsigned short protocol = 0;
unsigned short srcPort = 0;
unsigned short dstPort = 0;
unsigned short ack = 0;
unsigned short action = 0;
int sprintfResult = 0;
/* Retrieving the fields of the kernel rules from the user rule */
if (!getNameFromUserRule(&userRule, name, userRuleNum))
{
return 0;
}
if (!getDirectionFromUserRule(&userRule, &direction, userRuleNum))
{
return 0;
}
if (!getSubnetFromUserRule(&userRule, &srcIp, &srcPrefixSize, userRuleNum))
{
return 0;
}
if (!getSubnetFromUserRule(&userRule, &dstIp, &dstPrefixSize, userRuleNum))
{
return 0;
}
if (!getProtocolFromUserRule(&userRule, &protocol, userRuleNum))
{
return 0;
}
if (!getPortFromUserRule(&userRule, &srcPort, userRuleNum))
{
return 0;
}
if (!getPortFromUserRule(&userRule, &dstPort, userRuleNum))
{
return 0;
}
if (!getAckFromUserRule(&userRule, &ack, userRuleNum))
{
return 0;
}
if (!getActionFromUserRule(&userRule, &action, userRuleNum))
{
return 0;
}
skipWhiteSpaces(&userRule);
if (!isEndOfLine(userRule))
{
printf("User-rule #%d: too many arguments.\n", userRuleNum);
return 0;
}
if (!verifyRuleMakeSense(userRuleNum, protocol, ack, srcPort, dstPort))
{
return 0;
}
/* Writing the fields into the kernel rule buffer */
sprintfResult = sprintf(kernelRules, "%s %hu %d %hu %d %hu %hu %hu %hu %hu %hu\n",
name, direction, srcIp, srcPrefixSize, dstIp, dstPrefixSize, protocol,
srcPort, dstPort, ack, action);
if (sprintfResult == -1)
{
printf("User-rule #%d: Error in sprintf.\n", userRuleNum);
return 0;
}
return sprintfResult;
}
