int main(int argc, char *argv[]) {
FILE *theJFile;
FILE *theASMFile;
char token[200];
theJFile = fopen(argv[1], "r");
fileName = malloc(strlen(argv[1]) + 2);
strncpy(fileName, argv[1], strlen(argv[1]) - 2);
theASMFile = fopen(strcat(fileName, ".asm"), "w");
strncpy(fileName, argv[1], strlen(argv[1]) - 4);
/*fputs("\t.CODE\n", theASMFile);
fputs("\t.ADDR 0x0000\n", theASMFile);
fputs("STACK_START .UCONST 0x7FFF\n", theASMFile);
fputs("\tLC R6 STACK_START\n\tLC R5 STACK_START\n", theASMFile);*/
while(!feof(theJFile)) {
readToken(theJFile, token);
handleToken(theJFile, theASMFile, token);
}
/*fputs("\t.OS\n\t.CODE\n\t.ADDR 0x8200\n\tRTI\n", theASMFile);*/
free(fileName);
return 0;
}
void HttpDaemon :: readClient()
{
QTcpSocket *socket = (QTcpSocket*) sender();
if (socket->canReadLine()) {
QStringList tokens = QString(socket->readLine()).split(QRegExp("[ \r\n][ \r\n]*"));
handleToken(tokens, socket);
if (socket->state() == QTcpSocket::UnconnectedState) {
delete socket;
}
}
}
// Handle single char from input
void handleChar(char c) {
if(c == ' ' || c == '\n') {
if(bufferLength > 0) {
// A space or newline, and not empyt buffer, so a new token is ready
handleToken();
}
}
else {
// Not space or newline, we add it to the current token
buffer[bufferLength] = c;
bufferLength++;
}
}
// {{{ Message Management
// {{{ handleMessage
int handleMessage(msg_t msg) {
switch (type(msg)) {
case REQUEST:
return handleRequest(msg);
case TOKEN:
return handleToken(msg);
case HELLO:
return handleHello(msg);
case HELLOREP:
return handleHelloRep(msg, NULL);
default:
fprintf(stderr, "======> Uknown message type <======\n");
return -1;
}
}
bool Parser::parse(QString pattern)
{
if(!pattern.isEmpty())
setExpression(pattern);
for(std::vector<Token *>::iterator iter = _tokens.begin(); iter != _tokens.end(); ++iter)
delete *iter;
_tokens.clear();
int previousPositon = 0;
while(_pos < pattern.length())
{
handleToken(findMatch());
// In the case where no progress is being made, exit returning false
if(previousPositon == _pos)
return false;
previousPositon = _pos;
}
return true;
}
// {{{ critSectionRequest
// Ask for critical section
int critSectionRequest() {
msg_t msg;
type(msg) = REQUEST;
char *ip_tmp = inet_ntoa(this_site.neighbours[0].sin_addr);
strncpy (ask(msg), ip_tmp, IPLONG);
// If already in SC just return -1
if (state != IDLE) {
if (_verbose) fprintf (stderr,"Already in critical section.\n");
return -1;
}
state = WAITING;
// Owns Token ?
if(tokenPresent)
return takeCriticalSection();
// Sends request to last
else if(last != -1) {
// Get ip of last
char *tmpter = getIPstrFromNb (last);
if (_verbose) fprintf (stdout, "Last is %d, sending it a request.\n", last);
strncpy(ip(msg), tmpter, IPLONG);
free (tmpter);
strncpy (ask(msg), inet_ntoa(this_site.neighbours[0].sin_addr), IPLONG);
if(sendMessageWithAdd(msg) == -1){
if (_verbose) fprintf (stderr, "======> Sending request failure... <======\n");
return -1;
}
// Arms a timer
time_t timeStart, timeCur;
int flags = fcntl(this_site.sdRecv, F_GETFL);
int flags2 = flags | O_NONBLOCK;
fcntl(this_site.sdRecv, F_SETFL, flags2);
timeStart = time(&timeStart);
timeCur = time(&timeCur);
// Wait for an answer
if (_verbose) fprintf (stdout, "Waiting for COMMIT.\n");
while(timeCur - timeStart < (2*TMESG)) {
timeCur = time(&timeCur);
if(recvMessage(&msg, NULL) == -1)
continue;
if (type(msg) == COMMIT)
return handleCommit(msg);
else {
// TODO: Work on reaction when receiving request while waiting commit
if (type(msg) == REQUEST) {
if (_verbose) fprintf (stdout, "Received a REQUEST instead of a COMMIT.\n");
}
else if (type(msg) == TOKEN){
last = -1;
return handleToken(msg);
}
else
handleMessage(msg);
}
}
// If receive no answers
if (_verbose) fprintf (stdout, "I didn't get any COMMIT, looking for the queue...\n");
fcntl(this_site.sdRecv, F_SETFL, flags);
memset (&msg, 0, SIZE);
type(msg) = SEARCH_QUEUE;
nb_acc(msg) = acces;
// Broadcast Search_Queue
if (_verbose) fprintf (stdout, "Broadcasting SEARCH_QUEUE.\n");
broadcast(msg);
msg_t max;
pos(max) = -1;
fcntl(this_site.sdRecv, F_SETFL, flags2);
timeStart = time(&timeStart);
timeCur = time(&timeCur);
// Wait for ACK_SEARCH_QUEUE
if (_verbose) fprintf (stdout, "Expecting ACK_SEARCH_QUEUE.\n");
while(timeCur - timeStart < 2*TMESG) {
timeCur = time(&timeCur);
memset (&msg, 0, SIZE);
if(recvMessage(&msg, NULL) == -1)
continue;
switch(type(msg)) {
case ACK_SEARCH_QUEUE:
if (_verbose) fprintf (stdout, "Got an ACK_SEARCH_QUEUE.\n");
// Save greatest position in the queue
if (pos(msg) > pos(max)) {
if (_verbose) fprintf (stdout, "New position in QUEUE : %d.\n", pos(msg));
memcpy(&max, &msg, SIZE);
}
break;
// Another site discovers the failure
case SEARCH_QUEUE:
if (isMe(ips(msg)))
continue;
if (_verbose) fprintf (stdout, "Another site discovered the failure.\n");
// The other site hasn't priority, just continue
if (nb_acc(msg) > acces)
continue;
// Both of sites have the same numbers of access, defines priority with ip
if (nb_acc(msg) == acces) {
char *ip_pers = inet_ntoa(this_site.neighbours[0].sin_addr);
if (strcmp(ip_pers, ips(msg)) <= 0)
continue;
}
// If the other has the priority, just change last and ask it for CS
unsigned long int ipa = (unsigned long int) inet_addr(ips(msg));
last = getNeighbour(ipa);
if (_verbose) fprintf (stdout, "I don't have priority, changing my last (%d) and asking for CS again.\n", last);
state = IDLE;
return critSectionRequest();
// TODO: Request processing
case REQUEST:
break;
default:
handleMessage(msg);
break;
}
}
if (_verbose) fprintf (stdout, "Waiting time passed.\n");
fcntl(this_site.sdRecv, F_SETFL, flags);
// No other site in the queue, juste regenerate TOKEN
if (pos(max) < 0) {
if (_verbose) fprintf (stdout, "No other sites in the queue, regenerate TOKEN (last = next)\n");
last = next;
tokenPresent = 1;
takeCriticalSection();
}
else {
// Ask for connection to the site with the highest position
unsigned long int ipa = (unsigned long int) inet_addr(ips(max));
last = getNeighbour(ipa);
if (_verbose) fprintf (stdout, "Ask for Connection, new last = %d\n", last);
strncpy(ip(msg), ips(max),IPLONG *sizeof(char));
if (next(max)) {
type(msg) = CONNECTION;
if (sendMessageWithAdd(msg) == -1)
return -1;
}
state = IDLE;
critSectionRequest();
}
}
else
if (_verbose) fprintf (stderr, "======> Last = -1, but don't have TOKEN <======\n");
return 0;
}
void handleToken(FILE *inStream, FILE *outStream, char *token) {
int n;
char name[200];
int starting_index;
int hasElse = 0;
int endif = 0;
if(strcmp(token, "+") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get values off top of stack
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tADD R0 R0 R1\n", outStream); // add and store in R0
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value onto top of stack
}
else if(strcmp(token, "-") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get values off top of stack
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tSUB R0 R0 R1\n", outStream); // subtract and store in R0
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value onto top of stack
}
else if(strcmp(token, "*") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get values off top of stack
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tMUL R0 R0 R1\n", outStream); // multiply and store in R0
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value onto top of stack
}
else if(strcmp(token, "/") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get values off top of stack
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tDIV R0 R0 R1\n", outStream); // divide and store in R0
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value onto top of stack
}
else if(strcmp(token, "%") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get values off top of stack
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tMOD R0 R0 R1\n", outStream); // mod and store in R0
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value onto top of stack
}
else if(strcmp(token, "lt") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get a
fputs("\tLDR R1 R6 #1\n", outStream); // get b
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tCMP R0 R1\n", outStream); // a - b
fprintf(outStream, "\tBRn %s_comp_%d\n", fileName, comp_index); // if negative, skip next 2 lines
fputs("\tCONST R0 #0\n", outStream); // false, so want to return 0
fprintf(outStream, "\tBRnzp %s_comp_%d\n", fileName, comp_index + 1); // skip next line
fprintf(outStream, "%s_comp_%d", fileName, comp_index);
fputs("\tCONST R0 #1\n", outStream); // true, so want to return 1
fprintf(outStream, "%s_comp_%d\n", fileName, comp_index + 1);
comp_index++;
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "le") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get a
fputs("\tLDR R1 R6 #1\n", outStream); // get b
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tCMP R0 R1\n", outStream); // a - b
fprintf(outStream, "\tBRnz %s_comp_%d\n", fileName, comp_index); // if negative or 0, skip next 2 lines
fputs("\tCONST R0 #0\n", outStream); // false, so want to return 0
fprintf(outStream, "\tBRnzp %s_comp_%d\n", fileName, comp_index + 1); // skip next line
fprintf(outStream, "%s_comp_%d", fileName, comp_index);
fputs("\tCONST R0 #1\n", outStream); // true, so want to return 1
fprintf(outStream, "%s_comp_%d\n", fileName, comp_index + 1);
comp_index++;
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "eq") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get a
fputs("\tLDR R1 R6 #1\n", outStream); // get b
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tCMP R0 R1\n", outStream); // a - b
fprintf(outStream, "\tBRz %s_comp_%d\n", fileName, comp_index); // if negative or 0, skip next 2 lines
fputs("\tCONST R0 #0\n", outStream); // false, so want to return 0
fprintf(outStream, "\tBRnzp %s_comp_%d\n", fileName, comp_index + 1); // skip next line
fprintf(outStream, "%s_comp_%d", fileName, comp_index);
fputs("\tCONST R0 #1\n", outStream); // true, so want to return 1
fprintf(outStream, "%s_comp_%d\n", fileName, comp_index + 1);
comp_index++;
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "gt") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get a
fputs("\tLDR R1 R6 #1\n", outStream); // get b
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tCMP R0 R1\n", outStream); // a - b
fprintf(outStream, "\tBRp %s_comp_%d\n", fileName, comp_index); // if negative or 0, skip next 2 lines
fputs("\tCONST R0 #0\n", outStream); // false, so want to return 0
fprintf(outStream, "\tBRnzp %s_comp_%d\n", fileName, comp_index + 1); // skip next line
fprintf(outStream, "%s_comp_%d", fileName, comp_index);
fputs("\tCONST R0 #1\n", outStream); // true, so want to return 1
fprintf(outStream, "%s_comp_%d\n", fileName, comp_index + 1);
comp_index++;
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "ge") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get a
fputs("\tLDR R1 R6 #1\n", outStream); // get b
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tCMP R0 R1\n", outStream); // a - b
fprintf(outStream, "\tBRzp %s_comp_%d\n", fileName, comp_index); // if negative or 0, skip next 2 lines
fputs("\tCONST R0 #0\n", outStream); // false, so want to return 0
fprintf(outStream, "\tBRnzp %s_comp_%d\n", fileName, comp_index + 1); // skip next line
fprintf(outStream, "%s_comp_%d", fileName, comp_index);
fputs("\tCONST R0 #1\n", outStream); // true, so want to return 1
fprintf(outStream, "%s_comp_%d\n", fileName, comp_index + 1);
comp_index++;
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "and") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get top two values from stack
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tAND R0 R0 R1\n", outStream); // bitwise and them
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "or") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get top two values from stack
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tOR R0 R0 R1\n", outStream); // bitwise or them
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "not") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get top value from stack
fputs("\tNOT R0 R0\n", outStream); // bitwise not
fputs("\tSTR R0 R6 #0\n", outStream); // push return value on top of stack
}
else if(strcmp(token, "drop") == 0) {
fputs("\tADD R6 R6 #1\n", outStream);
}
else if(strcmp(token, "dup") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // get value at top of stack
fputs("\tADD R6 R6 #-1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push value to new stack top
}
else if(strcmp(token, "swap") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // load top two values
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tSTR R1 R6 #0\n", outStream); // swap and push back to stack
fputs("\tSTR R0 R6 #1\n", outStream);
}
else if(strcmp(token, "rot") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // load top three values
fputs("\tLDR R1 R6 #1\n", outStream);
fputs("\tLDR R2 R6 #2\n", outStream);
fputs("\tSTR R0 R6 #1\n", outStream); // rotate them and push back to stack
fputs("\tSTR R1 R6 #2\n", outStream);
fputs("\tSTR R2 R6 #0\n", outStream);
}
else if(strcmp(token, "pick") == 0) {
fputs("\tLDR R0 R6 #0\n", outStream); // pop index val off top of stack
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tADD R0 R0 R6\n", outStream); // offset R6 by index value in R0
fputs("\tLDR R0 R0 #0\n", outStream); // load value at offset value
fputs("\tADD R6 R6 #-1\n", outStream); // update SP
fputs("\tSTR R0 R6 #0\n", outStream); // push return value to stack top
}
else if(strcmp(token, "if") == 0) {
ind+=2;
starting_index = ind;
fputs("\tLDR R0 R6 #0\n", outStream); // pop value off top of stack
fputs("\tADD R6 R6 #1\n", outStream); // update SP
fputs("\tCMPI R0 #0\n", outStream); // check if top of stack was true
fprintf(outStream, "\tBRz %s_%d\n", fileName, ind); // if false, break to assigned label
while(!endif) {
readToken(inStream, token);
if(strcmp(token, "if") == 0) {
handleToken(inStream, outStream, token);
}
else if(strcmp(token, "else") == 0) {
fprintf(outStream, "\tBRnzp %s_%d\n", fileName, starting_index + 1);
fprintf(outStream, "%s_%d\n", fileName, starting_index);
hasElse = 1;
}
else if(strcmp(token, "endif") == 0) {
fprintf(outStream, "%s_%d\n", fileName, starting_index + hasElse);
endif = 1;
}
else {
handleToken(inStream, outStream, token);
}
}
}
else if(strcmp(token, "defun") == 0) {
readToken(inStream, name);
if(!isAlnumString(name)) {
printf("Error: %s is not a valid function name. All characters in a function name must be alphanumeric.\n", name);
exit(1);
}
fputs("\t.CODE\n", outStream);
fputs("\t.FALIGN\n", outStream);
//writes name of function to file
fprintf(outStream, "%s\n", name);
//prologue
fputs("\tADD R6 R6 #-3\n", outStream); // allocate 3 slots for FP, RA, RV
fputs("\tSTR R7 R6 #1\n", outStream); // save RA that was stored in R7
fputs("\tSTR R5 R6 #0\n", outStream); // save caller FP that is the value of R5
fputs("\tADD R5 R6 #0\n", outStream); // set up local FP to begin at current stack top
}
else if(strcmp(token, "return") == 0) {
//epilogue
fputs("\tLDR R0 R6 #0\n", outStream); // load value from top of stack
fputs("\tSTR R0 R5 #2\n", outStream); // put this value into RV address
fputs("\tADD R6 R5 #0\n", outStream); // move top of stack back to local frame
fputs("\tLDR R5 R6 #0\n", outStream); // restore caller FP
fputs("\tLDR R7 R6 #1\n", outStream); // restore RA
fputs("\tADD R6 R6 #2\n", outStream); // free RA, FP; top of stack is RV
fputs("\tRET\n", outStream); // return
}
else if(isDecimalString(token)) {
fprintf(outStream, "\tCONST R0 #%s\n", token);
fputs("\tSTR R0 R6 #-1\n", outStream);
fputs("\tADD R6 R6 #-1\n", outStream);
}
else if(isHexString(token)) {
fprintf(outStream, "\tCONST R0 %s\n", token);
fputs("\tSTR R0 R6 #-1\n", outStream);
fputs("\tADD R6 R6 #-1\n", outStream);
}
else if(isAlnumString(token)) {
fprintf(outStream, "\tJSR %s\n", token); // Jump to function name
}
else {
printf("Error: %s is not a valid token in J.\n", token);
exit(1);
}
printf("%s\n", token);
}
char OSISXHTMLXS::processText(SWBuf &text, const SWKey *key, const SWModule *module) {
char *from;
char token[4096];
int tokpos = 0;
bool intoken = false;
bool inEsc = false;
SWBuf lastTextNode;
MyUserDataXS *userData = (MyUserDataXS *)createUserData(module, key);
SWBuf orig = text;
from = orig.getRawData();
text = "";
for (;*from; from++) {
if (*from == '<') {
intoken = true;
tokpos = 0;
token[0] = 0;
token[1] = 0;
token[2] = 0;
inEsc = false;
continue;
}
if (*from == '&') {
intoken = true;
tokpos = 0;
token[0] = 0;
token[1] = 0;
token[2] = 0;
inEsc = true;
continue;
}
if (inEsc) {
if (*from == ';') {
intoken = inEsc = false;
userData->lastTextNode = lastTextNode;
if (!userData->suspendTextPassThru) { //if text through is disabled no tokens should pass, too
handleEscapeString(text, token, userData);
}
lastTextNode = "";
continue;
}
}
if (!inEsc) {
if (*from == '>') {
intoken = false;
userData->lastTextNode = lastTextNode;
handleToken(text, token, userData);
lastTextNode = "";
continue;
}
}
if (intoken) {
if (tokpos < 4090) {
token[tokpos++] = *from;
token[tokpos+2] = 0;
}
}
else {
if ((!userData->supressAdjacentWhitespace) || (*from != ' ')) {
if (!userData->suspendTextPassThru) {
text.append(*from);
userData->lastSuspendSegment.size(0);
}
else userData->lastSuspendSegment.append(*from);
lastTextNode.append(*from);
}
userData->supressAdjacentWhitespace = false;
}
}
// THE MAIN PURPOSE OF THIS OVERRIDE FUNCTION: is to insure all opened HTML tags are closed
while (!userData->htmlTagStack->empty()) {
text.append((SWBuf)"</" + userData->htmlTagStack->top().c_str() + ">");
userData->htmlTagStack->pop();
}
delete userData;
return 0;
}
char SWBasicFilter::processText(std::string &text, const SWKey *key, const SWModule *module) {
char *from;
char token[4096];
int tokpos = 0;
bool intoken = false;
bool inEsc = false;
int escStartPos = 0, escEndPos = 0;
int tokenStartPos = 0, tokenEndPos = 0;
std::string lastTextNode;
BasicFilterUserData *userData = createUserData(module, key);
std::string orig = text;
from = &orig[0u];
text = "";
if (processStages & INITIALIZE) {
if (processStage(INITIALIZE, text, from, userData)) { // processStage handled it all
delete userData;
return 0;
}
}
for (;*from; from++) {
if (processStages & PRECHAR) {
if (processStage(PRECHAR, text, from, userData)) // processStage handled this char
continue;
}
if (*from == tokenStart[tokenStartPos]) {
if (tokenStartPos == (tokenStartLen - 1)) {
intoken = true;
tokpos = 0;
token[0] = 0;
token[1] = 0;
token[2] = 0;
inEsc = false;
}
else tokenStartPos++;
continue;
}
if (*from == escStart[escStartPos]) {
if (escStartPos == (escStartLen - 1)) {
intoken = true;
tokpos = 0;
token[0] = 0;
token[1] = 0;
token[2] = 0;
inEsc = true;
}
else escStartPos++;
continue;
}
if (inEsc) {
if (*from == escEnd[escEndPos]) {
if (escEndPos == (escEndLen - 1)) {
intoken = inEsc = false;
userData->lastTextNode = lastTextNode;
if (!userData->suspendTextPassThru) { //if text through is disabled no tokens should pass, too
if ((!handleEscapeString(text, token, userData)) && (passThruUnknownEsc)) {
appendEscapeString(text, token);
}
}
escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
lastTextNode = "";
continue;
}
}
}
if (!inEsc) {
if (*from == tokenEnd[tokenEndPos]) {
if (tokenEndPos == (tokenEndLen - 1)) {
intoken = false;
userData->lastTextNode = lastTextNode;
if ((!handleToken(text, token, userData)) && (passThruUnknownToken)) {
text += tokenStart;
text += token;
text += tokenEnd;
}
escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
lastTextNode = "";
continue;
}
}
}
if (intoken) {
if (tokpos < 4090) {
token[tokpos++] = *from;
token[tokpos+2] = 0;
}
}
else {
if ((!userData->supressAdjacentWhitespace) || (*from != ' ')) {
if (!userData->suspendTextPassThru) {
text.push_back(*from);
userData->lastSuspendSegment.clear();
}
else userData->lastSuspendSegment.push_back(*from);
lastTextNode.push_back(*from);
}
userData->supressAdjacentWhitespace = false;
}
if (processStages & POSTCHAR)
processStage(POSTCHAR, text, from, userData);
}
if (processStages & FINALIZE)
processStage(FINALIZE, text, from, userData);
delete userData;
return 0;
}
Ast::Block* Parser::run()
{
current = ts.begin();
while(handleToken() && current != ts.end());
return program;
}
void PcreParser::handleToken(RegexpToken token)
{
QRegExp rx;
QRegExp characterClass;
QRegExp bracketExpressionLiteral("[^\\\\[\\]\\.]|\\\\[^a-zA-Z0-9]");
QRegExp bracketExpressionRange(_syntax[T_BRACKET_EXPRESSION_RANGE]);
QRegExp flagClose;
Token *openingToken;
QString character;
QString tmp;
switch(token)
{
case T_LITERAL:
case T_ALTERNATION:
case T_ANY_CHARACTER:
case T_STARTING_POSITION:
case T_ENDING_POSITION:
case T_BACKREFERENCE:
case T_WORD:
case T_NOT_WORD:
case T_DIGIT:
case T_NOT_DIGIT:
case T_SPACE:
case T_NOT_SPACE:
case T_WORD_BOUNDARY:
case T_NOT_WORD_BOUNDARY:
case T_OCTAL_CHAR:
case T_NAMED_BACKREFERENCE:
case T_FIRST_MATCHING_POSITION:
case T_START_OF_STRING:
case T_END_OF_STRING:
case T_END_OF_STRING_WITH_CLOSING_EOL:
case T_ALNUM:
case T_ALPHA:
case T_BLANK:
case T_CNTRL:
case T_GRAPH:
case T_LOWER:
case T_PRINT:
case T_PUNCT:
case T_UPPER:
case T_XDIGIT:
case T_HORIZONTAL_WHITESPACE:
case T_NOT_HORIZONTAL_WHITESPACE:
case T_VERTICAL_WHITESPACE:
case T_NOT_VERTICAL_WHITESPACE:
case T_BELL:
case T_BACKSPACE:
case T_ESCAPE:
case T_FORM_FEED:
case T_LINE_FEED:
case T_HORIZONTAL_TAB:
case T_HEXADECIMAL_CHAR:
_tokens.push_back(new Token(token, _expression.mid(_pos, _matchLength)));
_pos += _matchLength;
break;
case T_GROUPING_OPEN:
case T_REVERSED_CAPTURING_GROUPING_OPEN:
case T_NAMED_GROUPING_OPEN:
openingToken = new Token(token, _expression.mid(_pos, _matchLength));
_tokens.push_back(openingToken);
_pos += _matchLength;
rx.setPattern(_syntax[T_GROUPING_CLOSE]);
while(rx.indexIn(_expression, _pos) != _pos && _pos < _expression.length())
handleToken(findMatch());
if(rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_GROUPING_CLOSE, _expression.mid(_pos, 1)));
_pos += 1;
}
else
openingToken->setType(T_ERROR);
break;
case T_BRACKET_EXPRESSION_OPEN:
case T_NEGATED_BRACKET_EXPRESSION_OPEN:
openingToken = new Token(token, _expression.mid(_pos, _matchLength));
_tokens.push_back(openingToken);
_pos += _matchLength;
rx.setPattern(_syntax[T_BRACKET_EXPRESSION_CLOSE]);
// Look for a "[]...]" or "[^]...]" including a literal close bracket in
// the first position of the bracket expression
if(rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_LITERAL, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
}
while(rx.indexIn(_expression, _pos) != _pos && _pos < _expression.length())
{
bool matched = false;
if(matched == false && bracketExpressionRange.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_BRACKET_EXPRESSION_RANGE, _expression.mid(_pos, bracketExpressionRange.matchedLength())));
_pos += bracketExpressionRange.matchedLength();
}
if(matched == false && bracketExpressionLiteral.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_LITERAL, _expression.mid(_pos, bracketExpressionLiteral.matchedLength())));
_pos += bracketExpressionLiteral.matchedLength();
}
characterClass.setPattern(_syntax[T_WORD]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_WORD, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_NOT_WORD]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_NOT_WORD, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_DIGIT]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_DIGIT, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_NOT_DIGIT]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_NOT_DIGIT, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_SPACE]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_SPACE, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_NOT_SPACE]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_NOT_SPACE, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_WORD_BOUNDARY]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_WORD_BOUNDARY, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_NOT_WORD_BOUNDARY]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_NOT_WORD_BOUNDARY, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_BELL]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_BELL, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_ESCAPE]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_ESCAPE, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_FORM_FEED]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_FORM_FEED, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_LINE_FEED]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_LINE_FEED, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_HORIZONTAL_TAB]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_HORIZONTAL_TAB, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
characterClass.setPattern(_syntax[T_OCTAL_CHAR]);
if(matched == false && characterClass.indexIn(_expression, _pos) == _pos)
{
matched = true;
_tokens.push_back(new Token(T_OCTAL_CHAR, _expression.mid(_pos, characterClass.matchedLength())));
_pos += characterClass.matchedLength();
}
if(!matched)
{
_tokens.push_back(new Token(T_ERROR, _expression.mid(_pos, 1)));
++_pos;
}
}
if(rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_BRACKET_EXPRESSION_CLOSE,
_expression.mid(_pos, rx.matchedLength()))
);
_pos += rx.matchedLength();
}
else
openingToken->setType(T_ERROR);
break;
case T_POSITIVE_LOOKAHEAD_ASSERTION_OPEN:
case T_NEGATIVE_LOOKAHEAD_ASSERTION_OPEN:
case T_POSITIVE_LOOKBEHIND_ASSERTION_OPEN:
case T_NEGATIVE_LOOKBEHIND_ASSERTION_OPEN:
openingToken = new Token(token, _expression.mid(_pos, _matchLength));
_tokens.push_back(openingToken);
_pos += _matchLength;
rx.setPattern(_syntax[T_ASSERTION_CLOSE]);
while(rx.indexIn(_expression, _pos) != _pos && _pos < _expression.length())
handleToken(findMatch());
if(rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_ASSERTION_CLOSE, _expression.mid(_pos, 1)));
_pos += 1;
}
else
openingToken->setType(T_ERROR);
break;
case T_REPEAT_ZERO_OR_ONE:
case T_REPEAT_ANY_NUMBER:
case T_REPEAT_ONE_OR_MORE:
case T_REPEAT_SPECIFIED:
case T_REPEAT_ZERO_OR_ONE_NONGREEDY:
case T_REPEAT_ANY_NUMBER_NONGREEDY:
case T_REPEAT_ONE_OR_MORE_NONGREEDY:
case T_REPEAT_SPECIFIED_NONGREEDY:
case T_REPEAT_ZERO_OR_ONE_POSSESSIVE:
case T_REPEAT_ANY_NUMBER_POSSESSIVE:
case T_REPEAT_ONE_OR_MORE_POSSESSIVE:
case T_REPEAT_SPECIFIED_POSSESSIVE:
switch(_tokens[_tokens.size()-1]->type())
{
case T_POSITIVE_LOOKAHEAD_ASSERTION_OPEN:
case T_NEGATIVE_LOOKAHEAD_ASSERTION_OPEN:
case T_POSITIVE_LOOKBEHIND_ASSERTION_OPEN:
case T_NEGATIVE_LOOKBEHIND_ASSERTION_OPEN:
case T_REPEAT_ZERO_OR_ONE:
case T_REPEAT_ANY_NUMBER:
case T_REPEAT_ONE_OR_MORE:
case T_REPEAT_SPECIFIED:
case T_REPEAT_ZERO_OR_ONE_NONGREEDY:
case T_REPEAT_ANY_NUMBER_NONGREEDY:
case T_REPEAT_ONE_OR_MORE_NONGREEDY:
case T_REPEAT_SPECIFIED_NONGREEDY:
case T_REPEAT_ZERO_OR_ONE_POSSESSIVE:
case T_REPEAT_ANY_NUMBER_POSSESSIVE:
case T_REPEAT_ONE_OR_MORE_POSSESSIVE:
case T_REPEAT_SPECIFIED_POSSESSIVE:
case T_GROUPING_OPEN:
case T_REVERSED_CAPTURING_GROUPING_OPEN:
case T_NAMED_GROUPING_OPEN:
_tokens.push_back(new Token(T_ERROR, _expression.mid(_pos, _matchLength)));
_pos += _matchLength;
break;
case T_LITERAL:
// Requires a bit of extra work to separate the last character from
// the literal
character = _tokens[_tokens.size()-1]->value().right(1);
tmp = _tokens[_tokens.size()-1]->value();
if(tmp.size() > 1)
{
tmp.truncate(tmp.length() - 1);
_tokens[_tokens.size()-1]->setValue(tmp);
_tokens.push_back(new Token(T_LITERAL, character));
}
default:
_tokens.push_back(new Token(token, _expression.mid(_pos, _matchLength)));
_pos += _matchLength;
}
break;
case T_COMMENT_OPEN:
openingToken = new Token(token, _expression.mid(_pos, _matchLength));
_tokens.push_back(openingToken);
_pos += _matchLength;
// Comments contain one literal comment message lasting up until the
// next closing paren
rx.setMinimal(true);
rx.setPattern(QString(".*(?=") + _syntax[T_COMMENT_CLOSE] + ")");
if(rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_LITERAL, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
}
rx.setPattern(_syntax[T_COMMENT_CLOSE]);
if(rx.indexIn(_expression, _pos) != _pos)
openingToken->setType(T_ERROR);
else
{
_tokens.push_back(new Token(T_COMMENT_CLOSE, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
}
break;
case T_QUOTE_SEQUENCE_OPEN:
openingToken = new Token(token, _expression.mid(_pos, _matchLength));
_tokens.push_back(openingToken);
_pos += _matchLength;
// Quote sequences are literal up until a closing \E
rx.setMinimal(true);
rx.setPattern(QString(".*(?=") + _syntax[T_QUOTE_SEQUENCE_CLOSE] + ")");
if(rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_LITERAL, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
}
rx.setPattern(_syntax[T_QUOTE_SEQUENCE_CLOSE]);
if(rx.indexIn(_expression, _pos) != _pos)
openingToken->setType(T_ERROR);
else
{
_tokens.push_back(new Token(T_QUOTE_SEQUENCE_CLOSE, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
}
break;
case T_FLAGS_OPEN:
openingToken = new Token(token, _expression.mid(_pos, _matchLength));
_tokens.push_back(openingToken);
_pos += _matchLength;
// Flag sections can contain a-zA-Z- characters and end with a close
// paren, if we encounter anything else then we'll stop trying to match
// it as a flag and mark the opening as an error
rx.setMinimal(true);
rx.setPattern(QString("[a-zA-Z-]*") + _syntax[T_FLAGS_CLOSE]);
if(rx.indexIn(_expression, _pos) != _pos)
openingToken->setType(T_ERROR);
else
{
flagClose.setPattern(_syntax[T_FLAGS_CLOSE]);
while(flagClose.indexIn(_expression, _pos) != _pos)
{
bool matched = false;
rx.setPattern(_syntax[T_FLAGS_NEGATION]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAGS_NEGATION, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
rx.setPattern(_syntax[T_FLAG_CASELESS]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAG_CASELESS, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
rx.setPattern(_syntax[T_FLAG_DOTALL]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAG_DOTALL, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
rx.setPattern(_syntax[T_FLAG_MULTILINE]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAG_MULTILINE, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
rx.setPattern(_syntax[T_FLAG_EXTENDED]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAG_EXTENDED, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
rx.setPattern(_syntax[T_FLAG_PCRE_EXTRA]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAG_PCRE_EXTRA, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
rx.setPattern(_syntax[T_FLAG_ANCHORED]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAG_ANCHORED, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
rx.setPattern(_syntax[T_FLAG_UNGREEDY]);
if(!matched && rx.indexIn(_expression, _pos) == _pos)
{
_tokens.push_back(new Token(T_FLAG_UNGREEDY, _expression.mid(_pos, rx.matchedLength())));
_pos += rx.matchedLength();
matched = true;
}
if(!matched)
{
_tokens.push_back(new Token(T_ERROR, _expression.mid(_pos, 1)));
++_pos;
}
}
_tokens.push_back(new Token(T_FLAGS_CLOSE, _expression.mid(_pos, flagClose.matchedLength())));
_pos += flagClose.matchedLength();
}
break;
default:
qDebug() << "Unknown token at position " << _pos << ": " << token;
qDebug() << "Value: " << _expression.mid(_pos, _matchLength);
_tokens.push_back(new Token(T_ERROR, _expression.mid(_pos, _matchLength)));
_pos += _matchLength;
}
}
