ExecutionLexer::Token ExecutionLexer::PullPsql()
{
int start = pos;
Take(); // consume the starting backslash
do {
int c = Take();
if (c < 0 || c == '\n') {
return Token(Token::PSQL, start, pos - start);
}
else if (c == '\\') {
if (Peek() == '\\') {
// skip over terminating double-backslash
Take();
return Token(Token::PSQL, start, pos - start - 2);
}
else {
// preserve starting backslash of next command
BackUp();
return Token(Token::PSQL, start, pos - start);
}
}
else if (c == '\'') {
PassSingleQuotedString(false);
}
} while (true);
}
DWORD WINAPI philosopherET(LPVOID number)
{
int *i = (int *)number;
while(true)
{
if(!mutexP())
continue;
printf("哲学家%d,思考中...\n",*i);
//尝试拿走右手边筷子
if(!Try(*i))
continue;
if(!Try((*i+1)%5))
continue;
//拿走筷子
Take(*i);
Take((*i+1)%5);
printf("哲学家%d，吃饭中\n",*i);
Sleep(1000);
//放下筷子
release(*i); //放下右手边筷子
release(*i); //放下左手边筷子
mutexV();
}
return 0;
}
ExecutionLexer::Token ExecutionLexer::ReadCopyData0()
{
int start = pos;
bool backslashed = false;
do {
int c = Take();
if (c < 0) {
// well, this is really an error
return Token(Token::COPY_DATA, start, pos - start);
}
if (backslashed) {
if (c == '.') {
// remove the "\." from the returned token
return Token(Token::COPY_DATA, start, pos - 2 - start);
}
backslashed = false;
}
else {
if (c == '\\')
backslashed = true;
}
} while (true);
}
TokenPtr Scanner::ScanShiftOperator(const char chr)
{
std::string spell;
spell += TakeIt();
spell += Take(chr);
return Make(Token::Types::ShiftOp, spell);
}
void ExecutionLexer::PassSingleLineComment()
{
int c;
do {
c = Take();
if (c == '\n')
return;
} while (c >= 0);
}
int Buffer::TakeLineCRLF(std::string *dest) {
int after_next_line = OffsetToAfterNextCRLF();
if (after_next_line < 0)
return after_next_line;
else {
Take(after_next_line - 2, dest);
Skip(2); // Skip the CRLF
return after_next_line - 2;
}
}
void ExecutionLexer::PassDoubleQuotedString()
{
int c;
do {
c = Take();
if (c == '\"') {
if (Peek() != '\"')
return;
}
} while (c >= 0);
}
void ExecutionLexer::PassSingleQuotedString(bool escapeSyntax)
{
int c;
do {
c = Take();
if (c == '\'') {
if (Peek() != '\'')
return;
}
} while (c >= 0);
}
void ExecutionLexer::PassBlockComment()
{
int c;
do {
c = Take();
if (c == '*') {
if (Peek() == '/')
return;
}
} while (c >= 0);
}
void ExecutionLexer::PassWhitespace()
{
do {
int c = Take();
if (c < 0)
return;
if (!isspace((char) c)) {
BackUp();
return;
}
} while (true);
}
bool take()
{
if( Take(sem) )
{
if( (shared--)==0 ) Abort("test failed");
total_take++;
return true;
}
return false;
}
//消费者
DWORD WINAPI Consumer(LPVOID lpPara)
{
while(g_continue){
WaitForSingleObject(g_hEmptySemaphore,INFINITE);
WaitForSingleObject(g_hMutex,INFINITE);
Take();
Consume();
Sleep(1500);
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hFullSemaphore,1,NULL);
}
return 0;
}
var StrassenMM(Var M,Var N)
{
const size_t bound=64;//递归下界
size_t m=Size(M),p=Size(N),n=Size(At(N,0));
if (m<bound || p<bound || n<bound)
{
return Matrix::Dot(M,N);
}
size_t mm=bound,pp=bound,nn=bound;
while(mm<m)mm*=2;
while(pp<p)pp*=2;
while(nn<n)nn*=2;
var A=qPadRight(M,mm,pp);
var B=qPadRight(N,pp,nn);
return Take(StrassenDMM(A,B,mm,pp,nn,bound),1,m,1,n);
}
ExecutionLexer::Token ExecutionLexer::PullSql()
{
int start = pos;
do {
int c = Take();
if (c < 0) {
return Token(Token::SQL, start, pos - start);
}
// note that dollar-quoting takes priority over *everything* (except end of input of course)
if (c == '$')
PassDollarQuote();
else if (quoteStack.empty()) {
if (c == '\'')
PassSingleQuotedString(false); // FIXME handle E'...' flag for escape syntax
else if (c == '\"')
PassDoubleQuotedString();
else if (c == ';') {
// inclusive end character
int end = ++pos;
PassWhitespace();
return Token(Token::SQL, start, end - start);
}
else if (c == '-') {
if (Peek() == '-') {
PassSingleLineComment();
}
}
else if (c == '/') {
if (Peek() == '*') {
PassBlockComment();
}
}
else if (c == '\\') {
// exclusive end character
BackUp();
return Token(Token::SQL, start, pos - start);
}
}
} while (true);
}
TokenPtr SLScanner::ScanDirective()
{
std::string spell;
/* Take directive begin '#' */
Take('#');
/* Ignore white spaces (but not new-lines) */
IgnoreWhiteSpaces(false);
/* Scan identifier string */
StoreStartPos();
while (std::isalpha(UChr()))
spell += TakeIt();
/* Return as identifier */
return Make(Token::Types::Directive, spell);
}
void ExecutionLexer::PassDollarQuote()
{
if (isdigit(Peek())) return; // $1 etc. are not dollar-quoted strings
int start = pos;
int c;
do {
c = Take();
if (c < 0) return; // EOF inside dollar marker, oh well.
} while (c != '$');
std::string marker(buffer, pos - start);
if (!quoteStack.empty() && quoteStack.back() == marker) {
quoteStack.pop_back();
}
else {
quoteStack.push_back(marker);
}
}
int main (int argc, char ** argv) {
MOA_rec * MOA1 = NULL;
MOA_rec * MOA2 = NULL;
long * shape = NULL;
long * ind = NULL;
long * ind2 = NULL;
long flatIndex;
long i, rslt_ub, strides;
int finished = 1;
long * rslt = NULL;
long * rsltInd = NULL;
/*open once to erase previous contents then close */
outputfilename = "moamsa.out";
if (( outfile= fopen (outputfilename, "w")) == NULL) {
printf("Can not Open output file, exiting.\n");
return;
}
fclose(outfile);
createMOAStruct(&MOA1);
ind = (long *) mmalloc ( MOA1->dimn * sizeof(long));
ind2 = (long *) mmalloc ( MOA1->dimn * sizeof(long));
finished = 1;
while (finished != 0) {
switch (finished) {
case 0:
default:
printf("\n Good Bye\n");
break;
case 1:
deleteMOA (MOA1);
MOA1 = NULL;
free(ind);
ind = NULL;
free(ind2);
ind2 = NULL;
createMOAStruct(&MOA1);
printf ("\nEnter dimensionality:");
scanf("%ld", & MOA1->dimn);
ind = (long *) mmalloc ( MOA1->dimn * sizeof(long));
ind2 = (long *) mmalloc ( MOA1->dimn * sizeof(long));
shape = (long *) mmalloc ( MOA1->dimn * sizeof(long));
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter shape at dimension %ld:", i);
scanf("%ld", &shape[i]);
}
createMOA(shape /* shape*/, MOA1->dimn /* dimension*/, MOA1 /* MOA structure*/, -1, 0);
/*printMOA(MOA1); // we didn't create the tensor to print it*/
printf("created the MOA\n");
break;
case 2:
printMOA(MOA1);
break;
case 3:
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter index at dimn %ld:", i);
scanf("%ld", &ind[i]);
}
flatIndex = Gamma(ind, MOA1->dimn, shape, MOA1->dimn, 1);
printf("\n the flatIndex = %ld \n", flatIndex);
break;
case 4:
printf ("\nEnter flat index :" );
scanf("%ld", &flatIndex);
Gamma_Inverse(flatIndex, shape, MOA1->dimn, ind);
for (i = 0; i < MOA1->dimn; i++) {
printf("%ld", ind[i]);
}
break;
case 5:
MOA2 = (MOA_rec *) mmalloc(sizeof(MOA_rec));
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter take index at dimn %ld:", i);
scanf("%ld", &ind[i]);
}
Take (ind, MOA1->dimn, MOA1, MOA2);
printMOA(MOA2);
deleteMOA (MOA2);
MOA2 = NULL;
break;
case 6:
MOA2 = (MOA_rec *) mmalloc(sizeof(MOA_rec));
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter Drop index at dimn %ld:", i);
scanf("%ld", &ind[i]);
}
Drop (ind, MOA1->dimn, MOA1, MOA2);
printMOA(MOA2);
deleteMOA (MOA2);
MOA2 = NULL;
break;
/* case 5:
printf ("\nEnter flat index :" );
scanf("%d", &flatIndex);
Gamma_Inverse(flatIndex, shape, MOA1->dimn, ind);
LNghbCount = GetLowerNeighbors ( MOA1->dimn, shape, ind, &lNeighbors);
printf("\n Has %d Neighbors :", LNghbCount);
for (i = 0; i < LNghbCount; i++) {
printf(" %d ", lNeighbors[i]);
}
break;*/
case 7:
MOA2 = (MOA_rec *) mmalloc(sizeof(MOA_rec));
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter Cell index at dimn %ld:", i);
scanf("%ld", &ind[i]);
}
MOAGetLowerNeighbors (ind, MOA1, MOA2);
printMOA(MOA2);
printf("With Indices ");
for (i=0;i<MOA2->elements_ub; i++)
printf("%ld ", MOA2->indexes[i]);
printf("\n");
deleteMOA (MOA2);
MOA2 = NULL;
break;
case 8:
MOA2 = (MOA_rec *) mmalloc(sizeof(MOA_rec));
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter Cell index at dimn %ld:", i);
scanf("%ld", &ind[i]);
}
printf ("\nEnter The Stride Size:");
scanf("%ld", &flatIndex);
MOAGetHigherNeighbors (flatIndex, ind, MOA1, MOA2);
printMOA(MOA2);
printf("With Indices ");
for (i=0;i<MOA2->elements_ub; i++)
printf("%ld ", MOA2->indexes[i]);
printf("\n");
deleteMOA (MOA2);
MOA2 = NULL;
break;
case 9:
printf ("\nEnter The Size of the Wave:");
scanf("%ld", &flatIndex);
for (i = 0; i < MOA1->dimn; i++) {
ind[i] = 1;
}
getDiagonals (1, flatIndex, ind, MOA1);
break;
case 99:
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter Navigation Director at dimn %ld:", i);
scanf("%ld", &ind[i]);
}
for (i = 0; i < MOA1->dimn; i++) {
printf ("\nEnter Starting Cell index at dimn %ld:", i);
scanf("%ld", &ind2[i]);
}
printf ("\nEnter Strides: ");
scanf("%ld", &strides);
Navigate (ind, strides, ind2, MOA1, &rslt, &rsltInd, &rslt_ub);
printf("rslt_ub = %ld \n", rslt_ub);
for (i=0;i<rslt_ub; i++)
printf("%ld at %ld \n", rslt[i],rsltInd [i]);
printf("\n");
free(rslt);
rslt = NULL;
free(rsltInd);
rsltInd = NULL;
break;
}
printf ("\n1: Re-Define MOA\n");
printf ("2: Print MOA\n");
printf ("3: Gamma\n");
printf ("4: Gamma_inverse\n");
printf ("5: Take\n");
printf ("6: Drop\n");
printf ("7: MOAGetLowerNeighbors\n");
printf ("8: MOAGetHigherNeighbors\n");
printf ("9: GetDiagonals\n");
printf ("0: Quit\n");
printf ("\nEnter op code:" );
scanf("%d", &finished);
if (finished == 0)
printf("\n Good Bye\n");
}
free(ind);
free(ind2);
deleteMOA (MOA1);
}
AutoRoot::AutoRoot(JSContext* ncx, jsval nvar) : cx(ncx), var(nvar), count(0) { Take(); }
AutoRoot::AutoRoot( jsval nvar) : cx(ScriptEngine::GetGlobalContext()), var(nvar), count(0) { Take(); }
var StrassenDMM(Var A,Var B,size_t m,size_t p,size_t n,size_t bound)//m为M行数，n为N列数，p为n行数，bound为递归下界
{
if(m<=bound||n<=bound||p<=bound)
return Matrix::Dot(A,B);
else
{
var A11=Take(A,1,m/2,1,p/2);
var A12=Take(A,1,m/2,p/2+1,p);
var A21=Take(A,m/2+1,m,1,p/2);
var A22=Take(A,m/2+1,m,p/2+1,p);
var B11=Take(B,1,p/2,1,n/2);
var B12=Take(B,1,p/2,n/2+1,n);
var B21=Take(B,p/2+1,p,1,n/2);
var B22=Take(B,p/2+1,p,n/2+1,n);
var S1=Matrix::Add(A21,A22);
var S2=Matrix::Sub(S1,A11);
var S3=Matrix::Sub(A11,A21);
var S4=Matrix::Sub(A12,S2);
var T1=Matrix::Sub(B12,B11);
var T2=Matrix::Sub(B22,T1);
var T3=Matrix::Sub(B22,B12);
var T4=Matrix::Sub(T2,B21);
var P1=Matrix::StrassenDMM(A11,B11,m/2,p/2,n/2,bound);
var P2=Matrix::StrassenDMM(A12,B21,m/2,p/2,n/2,bound);
var P3=Matrix::StrassenDMM(S4,B22,m/2,p/2,n/2,bound);
var P4=Matrix::StrassenDMM(A22,T4,m/2,p/2,n/2,bound);
var P5=Matrix::StrassenDMM(S1,T1,m/2,p/2,n/2,bound);
var P6=Matrix::StrassenDMM(S2,T2,m/2,p/2,n/2,bound);
var P7=Matrix::StrassenDMM(S3,T3,m/2,p/2,n/2,bound);
var U1=Matrix::Add(P1,P2);
var U2=Matrix::Add(P1,P6);
var U3=Matrix::Add(U2,P7);
var U4=Matrix::Add(U2,P5);
var U5=Matrix::Add(U4,P3);
var U6=Matrix::Sub(U3,P4);
var U7=Matrix::Add(U3,P5);
var r=Vec(m);
for (size_t i=0;i<m;++i)
{
var &c=At(r,i);
c=Vec(n);
}
for (size_t i=0;i<m/2;++i)
{
for (size_t j=0;j<n/2;++j)
{
Entry(r,i,j)=Entry(U1,i,j);
}
}
for (size_t i=0;i<m/2;++i)
{
for (size_t j=n/2;j<n;++j)
{
Entry(r,i,j)=Entry(U5,i,j-n/2);
}
}
for (size_t i=m/2;i<m;++i)
{
for (size_t j=0;j<n/2;++j)
{
Entry(r,i,j)=Entry(U6,i-m/2,j);
}
}
for (size_t i=m/2;i<m;++i)
{
for (size_t j=n/2;j<n;++j)
{
Entry(r,i,j)=Entry(U7,i-m/2,j-n/2);
}
}
return r;
}
}
void main() {
stack_type *store;
stack_type *undo;
int choice;
element_type input, output, check, cmd1, cmd2;
char sections[MAX][40] = {"Push 1 string", "Indicate top", "Pop 1 string", "Undo", "Exit"};
store = iniStack(store);
undo = iniStack(undo);
do {
choice = getMenu(sections, MAX);
switch (choice)
{
case 1:
while (getchar() != '\n');
printf("Type in a string: ");
scanf("%s", input.s);
Add(store, undo, input);
break;
case 2:
if (empty(store))
printf("Stack empty\n");
else {
printf("Top of the stack is: \n");
printf("%s\n", store->top->element.s);
}
break;
case 3: printf("Pop a string from the stack\n");
if (empty(store))
printf("Stack empty\n");
else
Take(store, undo);
break;
case 4:
while (getchar() != '\n');
printf("Type in %s\n", "UNDO");
scanf("%s", check.s);
if (strcmp(check.s, "UNDO") == 0)
{
if (!empty(undo))
{
cmd1 = pop(undo);
cmd2 = pop(undo);
printf("cmd1 = %s\n", cmd1.s);
printf("cmd2 = %s\n", cmd2.s);
if (strcmp(cmd2.s, "PUSH") == 0)
if (!empty(store))
output = pop(store);
if (strcmp(cmd2.s, "POP") == 0)
push(cmd1, store);
}
}
else
printf("Invalid command\n");
break;
case MAX: exit(1);
default: printf("The choice must be from 1 to %d\n", MAX);
break;
}
} while (choice != MAX);
}
static void Take(T *ar, int len) {
for ( int i = 0; i < len; ++i )
Take(ar[i]);
}
