int
eqk(void)
{
Blk *p, *q;
int skp, skq;
p = pop();
EMPTYS;
q = pop();
EMPTYSR(p);
skp = sunputc(p);
skq = sunputc(q);
if(skp == skq) {
arg1=p;
arg2=q;
savk = skp;
return(0);
}
if(skp < skq) {
savk = skq;
p = add0(p,skq-skp);
} else {
savk = skp;
q = add0(q,skp-skq);
}
arg1=p;
arg2=q;
return(0);
}
calc::calc(QWidget *parent) :
QMainWindow(parent)
{
setupUi(this);
setFixedSize(sizeHint());
clearall();
connect (Button1,SIGNAL(clicked()),this,SLOT(add1()));
connect (Button2,SIGNAL(clicked()),this,SLOT(add2()));
connect (Button3,SIGNAL(clicked()),this,SLOT(add3()));
connect (Button4,SIGNAL(clicked()),this,SLOT(add4()));
connect (Button5,SIGNAL(clicked()),this,SLOT(add5()));
connect (Button6,SIGNAL(clicked()),this,SLOT(add6()));
connect (Button7,SIGNAL(clicked()),this,SLOT(add7()));
connect (Button8,SIGNAL(clicked()),this,SLOT(add8()));
connect (Button9,SIGNAL(clicked()),this,SLOT(add9()));
connect (Button0,SIGNAL(clicked()),this,SLOT(add0()));
connect (backButton,SIGNAL(clicked()),this,SLOT(delnum()));
connect (pointButton,SIGNAL(clicked()),this,SLOT(insertpoint()));
connect (plusButton,SIGNAL(clicked()),this,SLOT(plus()));
connect (minusButton,SIGNAL(clicked()),this,SLOT(minus()));
connect (multiplyButton,SIGNAL(clicked()),this,SLOT(multiply()));
connect (divideButton,SIGNAL(clicked()),this,SLOT(divide()));
connect (equalButton,SIGNAL(clicked()),this,SLOT(equal()));
connect (CButton,SIGNAL(clicked()),this,SLOT(clearall()));
connect (actionAbout_Qt,SIGNAL(triggered()),this,SLOT(about()));
connect (actionExit,SIGNAL(triggered()),this,SLOT(close()));
connect (pmButton,SIGNAL(clicked()),this,SLOT(togglepm()));
}
int
dscale(void){
register struct blk *dd,*dr;
register struct blk *r;
int c;
dr = pop();
EMPTYS;
dd = pop();
EMPTYSR(dr);
fsfile(dd);
skd = sunputc(dd);
fsfile(dr);
skr = sunputc(dr);
if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)){
sputc(dr,skr);
pushp(dr);
errorrt("divide by 0\n");
}
c = k-skd+skr;
if(c < 0)r = removr(dd,-c);
else {
r = add0(dd,c);
irem = 0;
}
arg1 = r;
arg2 = dr;
savk = k;
return(0);
}
BOOL FAR PASCAL NameDateDlgProc(HWND hDlg, WORD message, WORD wParam, LONG lParam)
{
switch(message)
{
case WM_INITDIALOG:
SetDlgItemText(hDlg, IDD_ND_CNAME, szc_name);
SetDlgItemText(hDlg, IDD_ND_MM, szmm);
SetDlgItemText(hDlg, IDD_ND_DD, szdd);
SetDlgItemText(hDlg, IDD_ND_YY, szyy);
SetWindowText(hDlg, szNDTitle);
return TRUE;
case WM_COMMAND:
switch (wParam)
{
case IDOK:
bNameDate = IDOK;
GetDlgItemText(hDlg, IDD_ND_CNAME, szc_name, COURSE_NAME_LENGTH+1);
GetDlgItemText(hDlg, IDD_ND_MM, szmm, 3);
GetDlgItemText(hDlg, IDD_ND_DD, szdd, 3);
GetDlgItemText(hDlg, IDD_ND_YY, szyy, 3);
if (!GoodDate(atoi(szmm), atoi(szdd), (atoi(szyy) + 1900)))
{
MessageBeep(0);
MessageBox(hDlg, "Invalid Date", szAppName, MB_OK | MB_ICONSTOP);
return FALSE;
}
add0(szmm);
add0(szdd);
add0(szyy);
EndDialog(hDlg, TRUE);
return TRUE;
case IDCANCEL:
bNameDate = IDCANCEL;
EndDialog(hDlg, FALSE);
return TRUE;
} /* switch (wParam) */
break;
} /* switch(message); */
return FALSE;
} /* NameDateDlgProc */
void viewMemory(int adresse, int taille, mot* mem) {
printf("\n\n------------- Etat de la memoire ------------");
printf("\n\n\tadr\tcodeop\tmode\tsource\tdest\t");
int i;
// On boucle sur les adresses mémoires
for (i=0; i<taille; i++) {
if (adresse+i < 2000) {
// Adresse mémoire instruction
printf("\n\t%d",adresse+i);
mot m = mem[adresse+i];
printf("\t%s\t%s\t%s\t%s",add0(toBinaire(m.codage.codeop),6),
add0(toBinaire(m.codage.mode),4),
add0(toBinaire(m.codage.source),3),
add0(toBinaire(m.codage.dest),3));
// Si le mode de registre fait intervenir des adresses indirect ou immédiate on affiche le 2eme mot
if (m.codage.mode == DIRREG || m.codage.mode == INDIMM || m.codage.mode == REGIMM || m.codage.mode == REGDIR) {
printf("\n\t%d",adresse+i+1);
mot m = mem[adresse+i+1];
printf("\t%s",add0(toBinaire(m.brut),16));
i++;
}
// Si le mode de registre est direct/immédiat l'instruction est sur 3 mots. On affiche donc les deux mots suivants
if (m.codage.mode == DIRIMM) {
printf("\n\t%d",adresse+i+1);
mot m = mem[adresse+i+1];
printf("\t%s",add0(toBinaire(m.brut),16));
printf("\n\t%d",adresse+i+2);
m = mem[adresse+i+2];
printf("\t%s",add0(toBinaire(m.brut),16));
i++;
i++;
}
}
else {
// Adresse mémoire donnée et pile
printf("\n\t%d",adresse+i);
mot m = mem[adresse+i];
printf("\t%s",add0(toBinaire(m.brut),16));
}
}
}
Blk*
scale(Blk *p, int n)
{
Blk *q, *s, *t;
t = add0(p,n);
q = salloc(1);
sputc(q,n);
s = dcexp(inbas,q);
release(q);
q = div(t,s);
release(t);
release(s);
release(rem);
sputc(q,n);
return(q);
}
MobileWindow::MobileWindow(MusicPlayer* player)
{
ui.setupUi(this);
this->player = player;
//initFolderList();
// SIGNALS
// CALL NUMBERS
connect(ui.call1Button, SIGNAL(clicked()), this, SLOT(add1()));
connect(ui.call2Button, SIGNAL(clicked()), this, SLOT(add2()));
connect(ui.call3Button, SIGNAL(clicked()), this, SLOT(add3()));
connect(ui.call4Button, SIGNAL(clicked()), this, SLOT(add4()));
connect(ui.call5Button, SIGNAL(clicked()), this, SLOT(add5()));
connect(ui.call6Button, SIGNAL(clicked()), this, SLOT(add6()));
connect(ui.call7Button, SIGNAL(clicked()), this, SLOT(add7()));
connect(ui.call8Button, SIGNAL(clicked()), this, SLOT(add8()));
connect(ui.call9Button, SIGNAL(clicked()), this, SLOT(add9()));
connect(ui.call0Button, SIGNAL(clicked()), this, SLOT(add0()));
connect(ui.callAsteriskButton, SIGNAL(clicked()), this, SLOT(addAsterisk()));
connect(ui.callHashButton, SIGNAL(clicked()), this, SLOT(addHash()));
// CALL, HANG UP AND DELETE BUTTONS
connect(ui.removeButton, SIGNAL(clicked()), this, SLOT(removeDigit()));
connect(ui.callButton, SIGNAL(clicked()), this, SLOT(call()));
connect(ui.hangUpButton, SIGNAL(clicked()), this, SLOT(hangUp()));
// CONTACTS
connect(ui.contactList, SIGNAL(itemSelectionChanged()), this, SLOT(contactSelected()));
// FILL CONTACTS
ddbb.readFromFile("ddbb\\contacts.xml");
QList<Contact*> contacts = ddbb.getContacts();
foreach (Contact* c,contacts) {
ui.contactList->addItem(c->name);
}
int
dscale(void)
{
Blk *dd, *dr, *r;
int c;
dr = pop();
EMPTYS;
dd = pop();
EMPTYSR(dr);
fsfile(dd);
skd = sunputc(dd);
fsfile(dr);
skr = sunputc(dr);
if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)) {
sputc(dr,skr);
pushp(dr);
Bprint(&bout,"divide by 0\n");
return(1);
}
if(sfbeg(dd) == 1 || (sfbeg(dd) == 0 && sbackc(dd) == 0)) {
sputc(dd,skd);
pushp(dd);
return(1);
}
c = k-skd+skr;
if(c < 0)
r = removr(dd,-c);
else {
r = add0(dd,c);
irem = 0;
}
arg1 = r;
arg2 = dr;
savk = k;
return(0);
}
/* funkcja tworzy bloki tworzace tetramino, zwalnia pamiec juz istniejacych,
* jesli takie sa */
void
create_color_blocks(int size)
{
enum color i;
/* zwalniam pamiec ze starych blokow jezeli istnieja */
for (i = 0; i < COLOR_COUNT; ++i)
if (block[i] != NULL)
SDL_FreeSurface(block[i]);
/* tworze nowe klocki */
for (i = 0; i < COLOR_COUNT; ++i) {
SDL_Rect r;
Uint32 color;
int th = size * 0.1f;
block[i] = create_surface(size, size);
/* srodek */
color = SDL_MapRGB(block[i]->format, block_color[i][0],
block_color[i][1], block_color[i][2]);
SDL_FillRect(block[i], NULL, color);
/* gora i lewy bok */
color = SDL_MapRGB(block[i]->format,
add0(block_color[i][0], COLOR_DIFF),
add0(block_color[i][1], COLOR_DIFF),
add0(block_color[i][2], COLOR_DIFF));
r.x = 0; r.y = 0; r.w = block[i]->w; r.h = th;
SDL_FillRect(block[i], &r, color);
r.w = th; r.h = block[i]->h - th;
SDL_FillRect(block[i], &r, color);
/* dol i prawy bok */
color = SDL_MapRGB(block[i]->format,
sub0(block_color[i][0], COLOR_DIFF),
sub0(block_color[i][1], COLOR_DIFF),
sub0(block_color[i][2], COLOR_DIFF));
r.y = block[i]->h - th; r.w = block[i]->w; r.h = th;
SDL_FillRect(block[i], &r, color);
r.x = block[i]->w - th; r.y = r.w = th; r.h = block[i]->h - th;
SDL_FillRect(block[i], &r, color);
}
// overlays
Uint32 color;
Uint8 alpha = 0x80;
selectOverlay = create_surface(size, size);
color = SDL_MapRGB(block[0]->format, 0, 0x80, 0xff);
SDL_FillRect(selectOverlay, NULL, color);
SDL_SetAlpha(selectOverlay, SDL_SRCALPHA, alpha);
markOverlay = create_surface(size, size);
color = SDL_MapRGB(block[0]->format, 0, 0, 0);
SDL_FillRect(markOverlay, NULL, color);
SDL_SetAlpha(markOverlay, SDL_SRCALPHA, alpha);
previewOverlay = create_surface(size, size);
color = SDL_MapRGB(block[0]->format, 0, 0xff, 0);
SDL_FillRect(previewOverlay, NULL, color);
SDL_SetAlpha(previewOverlay, SDL_SRCALPHA, alpha);
invalidOverlay = create_surface(size, size);
color = SDL_MapRGB(block[0]->format, 0xff, 0, 0);
SDL_FillRect(invalidOverlay, NULL, color);
SDL_SetAlpha(invalidOverlay, SDL_SRCALPHA, alpha);
}
int main(void)
{
int account_seller = 0;
int account_end =0;
int sockfd, new_fd; // listen on sock_fd, new connection on new_fd
struct addrinfo hints, *servinfo, *p;//
struct sockaddr_storage their_addr; // connector's address information
struct sockaddr_storage their_addr1;
socklen_t sin_size;
//addrlen is a local integer variable
//that should be set to sizeof(struct sockaddr_storage) before its address is passed to accept().
struct sigaction sa;
//(Also, this whole sigaction() thing might be new to you—that's ok. The code that's there is
//responsible for reaping zombie processes that appear as the fork()ed child processes exit.
int yes=1;
char s[INET6_ADDRSTRLEN];
int rv;
///////////////////////read auctionfile and divide data/////////////////////////////////////////
//char acc[30];
//char bcc[30];
//char ccc[30];
char * a1;
char * a2;
char * a3;
char * a4;
char * a5;
char * a6;
//char dcc[30];
//char ecc[30];
//char fcc[30];
//////////////////read file///////////////////
char n[160];
FILE *fp;
fp = fopen("Registration.txt","r");
fread(n,sizeof(char),160,fp);
fclose(fp);
///////////////////end read file ///////////////////////
// char str[] = "now # is the time for all # good men to come to the # aid of their country";
char delims[] = "\n";
char *result = NULL;
int i =1;
result = strtok( n, delims );
// for( i; result = NULL ; i++) {
while(result != NULL){
switch(i){
case 1:a1 = result; break;
case 2:a2 = result; break;
case 3:a3 = result; break;
case 4:a4 = result; break;
case 5:a5 = result; break;
case 6:a6 = result; break;
default: break;
}
i++;
// printf("%s\n", acc);
result = strtok( NULL, delims );
}
//printf("%s\n%s\n%s\n%s\n%s\n%s\n", a1,a2,a3,a4,a5,a6);
printf("this is server\n");
/////////////////////////////end read auctionfile and divide data/////////////////////////////////////
/*
struct users pass;
struct users * p_pass;
p_pass = &pass;
p_pass-> bidder1 = "1 Mary 123456 451912345";
p_pass-> bidder2 = "1 James pass123 451965432";
p_pass-> seller1 = "2 Taylor abc654 451934578";
p_pass-> seller2 = "2 Julia 654321 451900001";
//printf("%s");
*/
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE; // use my IP
if ((rv = getaddrinfo("nunki.usc.edu", PORT, &hints, &servinfo)) != 0) {
//getaddrinfo is a function. to do DNS lookup, fill out the structs you need.
//then you'd load that information by hand into a struct sockaddr_in
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
// loop through all the results and bind to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("server: socket");
continue;
}
//printf("\n\n sockfd is %d \n\n",sockfd);
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror("server: bind");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "server: failed to bind\n");
return 2;
}
freeaddrinfo(servinfo); // all done with this structure
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
/*sa.sa_handler = sigchld_handler; // reap all dead processes
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction");
exit(1);
}*/
print_ip(PORT);
printf("server: waiting for connections...\n");
while(1) { // main accept() loop
sin_size = sizeof their_addr;
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
//printf("new_fd is %d\n",new_fd);
if (new_fd == -1) {
perror("accept");
continue;
}
inet_ntop(their_addr.ss_family,
get_in_addr((struct sockaddr *)&their_addr),
s, sizeof s);
//printf("server: got connection from %s\n", s);
if (!fork()) { // this is the child process
int reply;
int flag_1;
char buf[MAXDATASIZE];
// char * no = "0";
close(sockfd); // child doesn't need the listener
// if (send(new_fd, "Hello, world!", 13, 0) == -1)
// perror("send");
reply = recv(new_fd, buf, MAXDATASIZE-1, 0);
// printf("buf is %s\n",buf);
///////////////////////extract pass_word from buf//////////////////////////////////
char delims1[] = "\n";
char *result1 = NULL;
result1 = strtok( buf, delims1 );
// printf("result1 is:%s\n",result1);
/////////////////////end extrac pass_word from buf/////////////////////////////
/////////////////////////////reply ////////////////////////////////
int authorize;
char *yes_no;
if ( (authorize = (strcmp((result1 + 2),a1) )) ==0 ){
printf("a1 access successful\n");
flag_1 = send(new_fd, "1", 1, 0);
// printf("%d\n !!!",flag_1);
}
else if( (authorize = (strcmp((result1 + 2),a2) ))==0 ){
printf("a2 access successful\n");
flag_1 = send(new_fd, "1", 1, 0);
}
else if( (authorize = (strcmp((result1 + 2),a3) ))==0 ){
printf("a3 access successful\n");
flag_1 = send(new_fd, "1", 1, 0);
}
else if( (authorize = (strcmp((result1 + 2),a4) ))==0 ){
printf("a4 access successful\n");
flag_1 = send(new_fd, "1", 1, 0);
}
else if( (authorize = (strcmp((result1 + 2),a5) ))==0 ){
printf("a5 access successful\n");
flag_1 = send(new_fd, "1", 1, 0);
}
else if( (authorize = (strcmp((result1 + 2),a6) ))==0 ){
printf("a6 access successful\n");
flag_1 = send(new_fd, "1", 1, 0);
}
else printf("don't have such a user\n\n");
if(authorize == 0){
yes_no = "yes";
}
else yes_no ="no";
//////////////////////////////end reply/////////////////////////////////
////////////////////////print receiving authentication request//////////////////////////////////////
char *b1;
char *b2;
char *b3;
char *b4;
// char *user_type;
// char *user_name;
// char *password;
// char *bank_account;
// char delims2[] = " ";
char *result2 = NULL;
// result2 = strtok( result1, delims2 );
result2 = strtok(buf, " \n");
i=1;
while(result2 != NULL){
// result2 = strtok( result1, delims2 );
switch(i){
case 1: b1 = result2; break;
case 2: b2 = result2; break;
case 3: b3 = result2; break;
case 4: b4 = result2; break;
default: printf("result2 is: \n",result2); break;
}
result2 = strtok( NULL, " \n" );
i++;
}
/* if(b1 = 1){
b1 = "bidder";
}
else if (b1 =2 ) b1 = "seller"; */
/* char *ptr, **pptr;
struct hostent *hptr;
// char str[32];
pptr=hptr->h_addr_list;
char* str = "nunki";
hptr = gethostbyname("str");
*/
printf("phase1: Auction Server request. User %s : Usernames %s ,Password: %s, Bank Accout: %s User IP Addr:%s. Authorized:%s\n",b1,b2,b3,b4,s,yes_no);
print_ip(b2);
///////////////////////////////print server IP addr_and_port number/////////////////////////////
char * server_ip_port = "1";
print_ip( server_ip_port);
// printf("Phase1 Auction Server IP Address: %s , PreAuction Port Number is %s\n",PORT);
///////////////////////////////end print server IP addr and port number /////////////////////////////////
// inet_ntop(hptr->h_addrtype, *pptr, str, sizeof(str)));
//////////////////////// end print print receiving authentication request ///////////////////////////////
close(new_fd);
exit(0);
}
close(new_fd); // parent doesn't need this
account_end ++;
//printf("account_ end is : %d\n\n",account_end);
if(account_end >= 4){
sleep(2);
printf("End of Phase 1 for Auction Server\n\n\n");
close(new_fd);
//printf("");
break;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////begin main function phase 2////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// close (sockfd);
sockfd = 0;
printf("\n\n sockfd is %d \n\n",sockfd);
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE; // use my IP
if ((rv = getaddrinfo("nunki.usc.edu", "1893", &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
// loop through all the results and bind to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("server: socket");
continue;
}
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror("server: bind");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "server: failed to bind\n");
return 2;
}
freeaddrinfo(servinfo); // all done with this structure
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
sa.sa_handler = sigchld_handler; // reap all dead processes
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction");
exit(1);
}
print_ip("1893");
printf("server: waiting for connections...\n");
printf("sockfd is %d\n ",sockfd );
// printf("hello world 1\n");
while(1) { // main accept() loop
sin_size = sizeof their_addr1;
int new_fd1;
// printf("hello world 2\n");
new_fd1 = accept(sockfd, (struct sockaddr *)&their_addr1, &sin_size);
// printf("hello world 3 \n");
if (new_fd1 == -1) {
perror("accept");
continue;
}
inet_ntop(their_addr1.ss_family,
get_in_addr((struct sockaddr *)&their_addr1),
s, sizeof s);
printf("server: got connection from %s\n", s);
if (!fork()) { // this is the child process
close(sockfd); // child doesn't need the listener
// if (send(new_fd, "Hello, world!", 13, 0) == -1)
// perror("send");
char buf[MAXDATASIZE] ={'0'};
recv(new_fd1, buf, MAXDATASIZE-1, 0);
int seller_num;
if((buf[0]=='T')&(buf[1]=='a')){
seller_num = 1;
}
else if((buf[0] =='J')&(buf[1])=='u') seller_num =2;
printf("phase 2: <Seller %d> send item lists.\n Phase2: %s \n",seller_num,buf);
// printf("End of Phase 2 for Auction Server\n");
close(new_fd1);
exit(0);
}
close(new_fd1); // parent doesn't need this
// int account_seller = 0;
account_seller++;
if(account_seller >=2 ){
// printf("end of phase 2 \n\n");
break;
// printf("end of phase 2 \n\n");
}
}
sleep(3);
printf("end of phase 2 \n\n");
//////////////////////////////end main function phase 2////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////begin phase 3//////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////begin phase 3 UDP bidder1 ///////////////////////////////////////////////
// int sockfd;
// struct addrinfo hints, *servinfo, *p;
// int rv;
int numbytes;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if ((rv = getaddrinfo("nunki.usc.edu", "3793", &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
// loop through all the results and make a socket
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("talker: socket");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "talker: failed to bind socket\n");
return 2;
}
////////////////////////////////////read broadcast Item lists //////////////////////////////////////////
char broadcastList_file[200] ={'0'};
// memcpy(itemList1_file,0,50);
// itemList1_file[50] ={'0'};
// FILE *fp;
FILE *fp3;
fp3 = fopen("broadcastList.txt","r");
fread(broadcastList_file,sizeof(char),200,fp3);
fclose(fp3);
printf("Phase3 broadcast Item list:\n %s \n",broadcastList_file);
/////////////////////////////////////end broadcast Item lists///////////////////////////////////////
///////////////////////////////////begin send to bidder1/////////////////////////////////////////////////
if ((numbytes = sendto(sockfd, broadcastList_file, strlen(broadcastList_file), 0,
p->ai_addr, p->ai_addrlen)) == -1) {
perror("talker: sendto");
exit(1);
}
/////////////////////////////////////end send to bidder1///////////////////////////////////////////////
////////////////////////////////////////begin receive reply from bidder1////////////////////////////////////////////
struct sockaddr_storage their_addr3;
char buf_b1[100] ={'0'};
socklen_t addr_len;
addr_len = sizeof their_addr3;
// printf("hello world1\n");
recvfrom(sockfd, buf_b1, 100 , 0,
p->ai_addr, &p->ai_addrlen);
printf("Phase3 : Auction server received a bidding from <Bidder 1>\n%s ", buf_b1);
printf("hello world1\n");
//////////////////////////////////////////end receive from bidder1//////////////////////////////////////////
/////////////////////////////////////////////begin divide bidding 1///////////////////////////////////////////////////
// char delims3[] = " \n";
char *a_1;
char *a_2;
char *a_3;
char *a_4;
char *a_5;
char *a_6;
char *a_7;
char *a_8;
char *a_9;
char *result_b1 = NULL;
int i_b1 =1;
result_b1 = strtok( buf_b1, " \n" );
// for( i; result = NULL ; i++) {
while(result_b1 != NULL){
switch(i_b1){
case 1:a_1 = result_b1; break;
case 2:a_2 = result_b1; break;
case 3:a_3 = result_b1; break;
case 4:a_4 = result_b1; break;
case 5:a_5 = result_b1; break;
case 6:a_6 = result_b1; break;
case 7:a_7 = result_b1; break;
case 8:a_8 = result_b1; break;
case 9:a_9 = result_b1; break;
default: break;
}
i_b1++;
// printf("%s\n", acc);
result_b1 = strtok( NULL, " \n" );
}
printf("\na_1,... a_9 is %s %s\n\n\n", a_1,a_9);
////////////////////////////////////////////end divide biding 2/////////////////////////////////////////////////
//////////////////////////////////begin phase 3 port number and IP address////////////////////////////////////////
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int port_phase3;
//char *p_ptr;
struct hostent *hptr;
char client_ip[40];
char s3[INET6_ADDRSTRLEN];
hptr = gethostbyname("nunki.usc.edu");
inet_ntop(hptr->h_addrtype,hptr->h_addr,s3,sizeof s3);
getsockname(sockfd,(struct sockaddr*)&client_addr,&client_len );
port_phase3 = ntohs(client_addr.sin_port);
printf("Phase3: Auction Server IP Address: %s Auction UDP Port number: %d \n",s3,port_phase3);
// print_ip("phase3_ip_port");
///////////////////////////////////end port number and IP address//////////////////////////////////////////////
freeaddrinfo(servinfo);
// printf("talker: sent %d bytes to %s\n", numbytes, argv[1]);
close(sockfd);
//////////////////////////////////////end phase 3 UDP bidder1////////////////////////////////////////////////////
////////////////////////////////////////////begin phase3 UDP Bidder2///////////////////////////////////////////////////////////////////////
// int numbytes;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if ((rv = getaddrinfo("nunki.usc.edu", "3893", &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
// loop through all the results and make a socket
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("talker: socket");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "talker: failed to bind socket\n");
return 2;
}
//////////////////////////////////// read broadcast Item lists to bidder2 //////////////////////////////////////////
// broadcastList_file[200] ={'0'};
// memcpy(itemList1_file,0,50);
// itemList1_file[50] ={'0'};
// FILE *fp;
FILE *fpb2;
fpb2 = fopen("broadcastList.txt","r");
fread(broadcastList_file,sizeof(char),200,fpb2);
fclose(fpb2);
// printf("Phase3 broadcast Item list:\n %s \n",broadcastList_file);
/////////////////////////////////////end broadcast Item listsc to bidder2///////////////////////////////////////
///////////////////////////////////begin send to bidder2/////////////////////////////////////////////////
if ((numbytes = sendto(sockfd, broadcastList_file, strlen(broadcastList_file), 0,
p->ai_addr, p->ai_addrlen)) == -1) {
perror("talker: sendto");
exit(1);
}
/////////////////////////////////////end send to bidder2///////////////////////////////////////////////
////////////////////////////////////////begin receive reply from bidder2////////////////////////////////////////////
struct sockaddr_storage their_addrb2;
char buf_b2[100] ={'0'};
// socklen_t addr_len;
addr_len = sizeof their_addrb2;
// printf("hello world1\n");
recvfrom(sockfd, buf_b2, 100 , 0,
p->ai_addr, &p->ai_addrlen);
printf("Phase3 : Auction server received a bidding from <Bidder 2>\n%s ", buf_b2);
// printf("hello world1\n");
//////////////////////////////////////////end receive from bidder2//////////////////////////////////////////
/////////////////////////////////////////////begin divide bidding 1///////////////////////////////////////////////////
// char delims3[] = " \n";
char *b_1;
char *b_2;
char *b_3;
char *b_4;
char *b_5;
char *b_6;
char *b_7;
char *b_8;
char *b_9;
char *b_10;
char *b_11;
char *b_12;
char *result_b2 = NULL;
int i_b2 =1;
result_b2 = strtok( buf_b2, " \n" );
// for( i; result = NULL ; i++) {
while(result_b2 != NULL){
switch(i_b2){
case 1:b_1 = result_b2; break;
case 2:b_2 = result_b2; break;
case 3:b_3 = result_b2; break;
case 4:b_4 = result_b2; break;
case 5:b_5 = result_b2; break;
case 6:b_6 = result_b2; break;
case 7:b_7 = result_b2; break;
case 8:b_8 = result_b2; break;
case 9:b_9 = result_b2; break;
case 10:b_10 = result_b2; break;
case 11:b_11 = result_b2; break;
case 12:b_12 = result_b2; break;
default: break;
}
i_b2++;
// printf("%s\n", acc);
result_b2 = strtok( NULL, " \n" );
}
printf("\nb_1,... b_12 is %s %s\n\n\n", b_1,b_12);
////////////////////////////////////////////end divide biding 2/////////////////////////////////////////////////
freeaddrinfo(servinfo);
// printf("talker: sent %d bytes to %s\n", numbytes, argv[1]);
close(sockfd);
////////////////////////////////////////////end phase3 UDP Bidder2///////////////////////////////////////////////////////////////////////
char zero[20] = "0";
//char *src = "80";
//char *result;
a_6 = add0(zero,a_6); a_3 = add0(zero,a_3);a_9 = add0(zero,a_9);b_3 = add0(zero,b_3);b_6 = add0(zero,b_6);
b_9 = add0(zero,b_9);b_12 = add0(zero,b_12);
////////////////////////////////////////////////////
////////////////////////////////////////////
char *cmp1;
char *cmp2;
char *cmp3;
char *cmp4;
char *cmp5;
//printf("a6 is :%s\n",b_6);
//printf("b1,b2,b3 is :%s %s %s\n",b_1,b_2,b_3);
cmp1 = cmp_function(b_1,b_2,b_3,a_1,a_2,a_3,a_4,a_5,a_6,a_7,a_8,a_9);
cmp2 = cmp_function(b_4,b_5,b_6,a_1,a_2,a_3,a_4,a_5,a_6,a_7,a_8,a_9);
cmp3 = cmp_function(b_7,b_8,b_9,a_1,a_2,a_3,a_4,a_5,a_6,a_7,a_8,a_9);
cmp4 = cmp_function(b_10,b_11,b_12,a_1,a_2,a_3,a_4,a_5,a_6,a_7,a_8,a_9);
//strlen exist_function(cmp1,cmp2,cmp3,cmp4,);
//printf("b_1,b_2,b_3 are \n%s%s%s\n",a_7,a_8,a_9);
if (exist_function(cmp1,cmp2,cmp3,cmp4,a_1,a_2,a_3) ==1 ) cmp5 = a_1;
if ( exist_function(cmp1,cmp2,cmp3,cmp4,a_4,a_5,a_6) ==1) cmp5 = a_4;
if ( exist_function(cmp1,cmp2,cmp3,cmp4,a_7,a_8,a_9) ==1 ) cmp5 =a_7;
//printf("\n\ncmp1,2,3,4 are: %s\n%s\n%s\n%s\n%s\n",cmp1,cmp2,cmp3,cmp4,cmp5);
char* d1;char *d2;char* d3;char *d4;char* d5;char *d6;char* d7;char *d8;char* d9;char *d10;
d1 = strtok(cmp1,",");d2 = strtok(NULL,",");
d3 = strtok(cmp2,",");d4 = strtok(NULL,",");
d5 = strtok(cmp3,",");d6 = strtok(NULL,",");
d7 = strtok(cmp4,",");d8 = strtok(NULL,",");
d9 = strtok(cmp5,",");d10= strtok(NULL,",");
//printf("\nd1,d2.. are %s%s%s%s%s%s%s%s%s%s\n",d1,d2,d3,d4,d5,d6,d7,d8,d9,d10);
printf("Item %s was sold at price %s\n",d1,d2);
printf("Item %s was sold at price %s\n",d3,d4);
printf("Item %s was sold at price %s\n",d5,d6);
printf("Item %s was sold at price %s\n",d7,d8);
printf("Item %s was sold at price %s\n",d9,d10);
/////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////end phase 3/////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
int k =0;
while(1){
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if ( k==0 ){
if ((rv = getaddrinfo("nunki.usc.edu", "4793", &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
}
else if ( k==1){
if ((rv = getaddrinfo("nunki.usc.edu", "4893", &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
}
else if( k==2){
if ((rv = getaddrinfo("nunki.usc.edu", "2793", &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
}
else if( k==3){
if ((rv = getaddrinfo("nunki.usc.edu", "2893", &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
}
else break;
k++;
// loop through all the results and connect to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("client: socket");
continue;
}
if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror("client: connect");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "client: failed to connect\n");
return 2;
}
inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
s, sizeof s);
printf("client: connecting to %s\n", s);
freeaddrinfo(servinfo); // all done with this structure
// printf("\nd1 is %s\n",d1);
if(k==0){
send(sockfd, d1,50,0);send(sockfd, d2,50,0);
send(sockfd, d9,50,0);send(sockfd, d10,50,0);
}
else if (k==1){
send(sockfd, d3,50,0);send(sockfd, d4,50,0);
send(sockfd, d5,50,0);send(sockfd, d6,50,0);
send(sockfd, d7,50,0);send(sockfd, d8,50,0);
}
else {
send(sockfd, d1,50,0);send(sockfd, d2,50,0);
send(sockfd, d3,50,0);send(sockfd, d4,50,0);
send(sockfd, d5,50,0);send(sockfd, d6,50,0);
send(sockfd, d7,50,0);send(sockfd, d8,50,0);
send(sockfd, d9,50,0);send(sockfd, d10,50,0);
}
/* if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
perror("recv");
exit(1);
}
buf[numbytes] = '\0';
printf("client: received '%s'\n",buf);
*/
close(sockfd);
}
////////////////////////////////////////send to bidder 2 TCP////////////////////////////////////////
printf("End of Phase 3 for Auction Server\n");
return 0;
}
void
commnds(void)
{
Blk *p, *q, **ptr, *s, *t;
long l;
Sym *sp;
int sk, sk1, sk2, c, sign, n, d;
while(1) {
Bflush(&bout);
if(((c = readc())>='0' && c <= '9') ||
(c>='A' && c <='F') || c == '.') {
unreadc(c);
p = readin();
pushp(p);
continue;
}
switch(c) {
case ' ':
case '\t':
case '\n':
case -1:
continue;
case 'Y':
sdump("stk",*stkptr);
Bprint(&bout, "all %ld rel %ld headmor %ld\n",all,rel,headmor);
Bprint(&bout, "nbytes %ld\n",nbytes);
Bprint(&bout, "longest %ld active %ld maxsize %ld\n", longest,
active, maxsize);
Bprint(&bout, "new all %d rel %d copy %d more %d lbytes %d\n",
lall, lrel, lcopy, lmore, lbytes);
lall = lrel = lcopy = lmore = lbytes = 0;
continue;
case '_':
p = readin();
savk = sunputc(p);
chsign(p);
sputc(p,savk);
pushp(p);
continue;
case '-':
subt();
continue;
case '+':
if(eqk() != 0)
continue;
binop('+');
continue;
case '*':
arg1 = pop();
EMPTY;
arg2 = pop();
EMPTYR(arg1);
sk1 = sunputc(arg1);
sk2 = sunputc(arg2);
savk = sk1+sk2;
binop('*');
p = pop();
if(savk>k && savk>sk1 && savk>sk2) {
sclobber(p);
sk = sk1;
if(sk<sk2)
sk = sk2;
if(sk<k)
sk = k;
p = removc(p,savk-sk);
savk = sk;
sputc(p,savk);
}
pushp(p);
continue;
case '/':
casediv:
if(dscale() != 0)
continue;
binop('/');
if(irem != 0)
release(irem);
release(rem);
continue;
case '%':
if(dscale() != 0)
continue;
binop('/');
p = pop();
release(p);
if(irem == 0) {
sputc(rem,skr+k);
pushp(rem);
continue;
}
p = add0(rem,skd-(skr+k));
q = add(p,irem);
release(p);
release(irem);
sputc(q,skd);
pushp(q);
continue;
case 'v':
p = pop();
EMPTY;
savk = sunputc(p);
if(length(p) == 0) {
sputc(p,savk);
pushp(p);
continue;
}
if(sbackc(p)<0) {
error("sqrt of neg number\n");
}
if(k<savk)
n = savk;
else {
n = k*2-savk;
savk = k;
}
arg1 = add0(p,n);
arg2 = dcsqrt(arg1);
sputc(arg2,savk);
pushp(arg2);
continue;
case '^':
neg = 0;
arg1 = pop();
EMPTY;
if(sunputc(arg1) != 0)
error("exp not an integer\n");
arg2 = pop();
EMPTYR(arg1);
if(sfbeg(arg1) == 0 && sbackc(arg1)<0) {
neg++;
chsign(arg1);
}
if(length(arg1)>=3) {
error("exp too big\n");
}
savk = sunputc(arg2);
p = dcexp(arg2,arg1);
release(arg2);
rewind(arg1);
c = sgetc(arg1);
if(c == -1)
c = 0;
else
if(sfeof(arg1) == 0)
c = sgetc(arg1)*100 + c;
d = c*savk;
release(arg1);
/* if(neg == 0) { removed to fix -exp bug*/
if(k>=savk)
n = k;
else
n = savk;
if(n<d) {
q = removc(p,d-n);
sputc(q,n);
pushp(q);
} else {
sputc(p,d);
pushp(p);
}
/* } else { this is disaster for exp <-127 */
/* sputc(p,d); */
/* pushp(p); */
/* } */
if(neg == 0)
continue;
p = pop();
q = salloc(2);
sputc(q,1);
sputc(q,0);
pushp(q);
pushp(p);
goto casediv;
case 'z':
p = salloc(2);
n = stkptr - stkbeg;
if(n >= 100) {
sputc(p,n/100);
n %= 100;
}
sputc(p,n);
sputc(p,0);
pushp(p);
continue;
case 'Z':
p = pop();
EMPTY;
n = (length(p)-1)<<1;
fsfile(p);
backc(p);
if(sfbeg(p) == 0) {
if((c = sbackc(p))<0) {
n -= 2;
if(sfbeg(p) == 1)
n++;
else {
if((c = sbackc(p)) == 0)
n++;
else
if(c > 90)
n--;
}
} else
if(c < 10)
n--;
}
release(p);
q = salloc(1);
if(n >= 100) {
sputc(q,n%100);
n /= 100;
}
sputc(q,n);
sputc(q,0);
pushp(q);
continue;
case 'i':
p = pop();
EMPTY;
p = scalint(p);
release(inbas);
inbas = p;
continue;
case 'I':
p = copy(inbas,length(inbas)+1);
sputc(p,0);
pushp(p);
continue;
case 'o':
p = pop();
EMPTY;
p = scalint(p);
sign = 0;
n = length(p);
q = copy(p,n);
fsfile(q);
l = c = sbackc(q);
if(n != 1) {
if(c<0) {
sign = 1;
chsign(q);
n = length(q);
fsfile(q);
l = c = sbackc(q);
}
if(n != 1) {
while(sfbeg(q) == 0)
l = l*100+sbackc(q);
}
}
logo = log2(l);
obase = l;
release(basptr);
if(sign == 1)
obase = -l;
basptr = p;
outdit = bigot;
if(n == 1 && sign == 0) {
if(c <= 16) {
outdit = hexot;
fw = 1;
fw1 = 0;
ll = 70;
release(q);
continue;
}
}
n = 0;
if(sign == 1)
n++;
p = salloc(1);
sputc(p,-1);
t = add(p,q);
n += length(t)*2;
fsfile(t);
if(sbackc(t)>9)
n++;
release(t);
release(q);
release(p);
fw = n;
fw1 = n-1;
ll = 70;
if(fw>=ll)
continue;
ll = (70/fw)*fw;
continue;
case 'O':
p = copy(basptr,length(basptr)+1);
sputc(p,0);
pushp(p);
continue;
case '[':
n = 0;
p = salloc(0);
for(;;) {
if((c = readc()) == ']') {
if(n == 0)
break;
n--;
}
sputc(p,c);
if(c == '[')
n++;
}
pushp(p);
continue;
case 'k':
p = pop();
EMPTY;
p = scalint(p);
if(length(p)>1) {
error("scale too big\n");
}
rewind(p);
k = 0;
if(!sfeof(p))
k = sgetc(p);
release(scalptr);
scalptr = p;
continue;
case 'K':
p = copy(scalptr,length(scalptr)+1);
sputc(p,0);
pushp(p);
continue;
case 'X':
p = pop();
EMPTY;
fsfile(p);
n = sbackc(p);
release(p);
p = salloc(2);
sputc(p,n);
sputc(p,0);
pushp(p);
continue;
case 'Q':
p = pop();
EMPTY;
if(length(p)>2) {
error("Q?\n");
}
rewind(p);
if((c = sgetc(p))<0) {
error("neg Q\n");
}
release(p);
while(c-- > 0) {
if(readptr == &readstk[0]) {
error("readstk?\n");
}
if(*readptr != 0)
release(*readptr);
readptr--;
}
continue;
case 'q':
if(readptr <= &readstk[1])
exits(0);
if(*readptr != 0)
release(*readptr);
readptr--;
if(*readptr != 0)
release(*readptr);
readptr--;
continue;
case 'f':
if(stkptr == &stack[0])
Bprint(&bout,"empty stack\n");
else {
for(ptr = stkptr; ptr > &stack[0];) {
dcprint(*ptr--);
}
}
continue;
case 'p':
if(stkptr == &stack[0])
Bprint(&bout,"empty stack\n");
else {
dcprint(*stkptr);
}
continue;
case 'P':
p = pop();
EMPTY;
sputc(p,0);
Bprint(&bout,"%s",p->beg);
release(p);
continue;
case 'd':
if(stkptr == &stack[0]) {
Bprint(&bout,"empty stack\n");
continue;
}
q = *stkptr;
n = length(q);
p = copy(*stkptr,n);
pushp(p);
continue;
case 'c':
while(stkerr == 0) {
p = pop();
if(stkerr == 0)
release(p);
}
continue;
case 'S':
if(stkptr == &stack[0]) {
error("save: args\n");
}
c = getstk() & 0377;
sptr = stable[c];
sp = stable[c] = sfree;
sfree = sfree->next;
if(sfree == 0)
goto sempty;
sp->next = sptr;
p = pop();
EMPTY;
if(c >= ARRAYST) {
q = copy(p,length(p)+PTRSZ);
for(n = 0;n < PTRSZ;n++) {
sputc(q,0);
}
release(p);
p = q;
}
sp->val = p;
continue;
sempty:
error("symbol table overflow\n");
case 's':
if(stkptr == &stack[0]) {
error("save:args\n");
}
c = getstk() & 0377;
sptr = stable[c];
if(sptr != 0) {
p = sptr->val;
if(c >= ARRAYST) {
rewind(p);
while(sfeof(p) == 0)
release(dcgetwd(p));
}
release(p);
} else {
sptr = stable[c] = sfree;
sfree = sfree->next;
if(sfree == 0)
goto sempty;
sptr->next = 0;
}
p = pop();
sptr->val = p;
continue;
case 'l':
load();
continue;
case 'L':
c = getstk() & 0377;
sptr = stable[c];
if(sptr == 0) {
error("L?\n");
}
stable[c] = sptr->next;
sptr->next = sfree;
sfree = sptr;
p = sptr->val;
if(c >= ARRAYST) {
rewind(p);
while(sfeof(p) == 0) {
q = dcgetwd(p);
if(q != 0)
release(q);
}
}
pushp(p);
continue;
case ':':
p = pop();
EMPTY;
q = scalint(p);
fsfile(q);
c = 0;
if((sfbeg(q) == 0) && ((c = sbackc(q))<0)) {
error("neg index\n");
}
if(length(q)>2) {
error("index too big\n");
}
if(sfbeg(q) == 0)
c = c*100+sbackc(q);
if(c >= MAXIND) {
error("index too big\n");
}
release(q);
n = getstk() & 0377;
sptr = stable[n];
if(sptr == 0) {
sptr = stable[n] = sfree;
sfree = sfree->next;
if(sfree == 0)
goto sempty;
sptr->next = 0;
p = salloc((c+PTRSZ)*PTRSZ);
zero(p);
} else {
p = sptr->val;
if(length(p)-PTRSZ < c*PTRSZ) {
q = copy(p,(c+PTRSZ)*PTRSZ);
release(p);
p = q;
}
}
seekc(p,c*PTRSZ);
q = lookwd(p);
if(q!=0)
release(q);
s = pop();
EMPTY;
salterwd(p, s);
sptr->val = p;
continue;
case ';':
p = pop();
EMPTY;
q = scalint(p);
fsfile(q);
c = 0;
if((sfbeg(q) == 0) && ((c = sbackc(q))<0)) {
error("neg index\n");
}
if(length(q)>2) {
error("index too big\n");
}
if(sfbeg(q) == 0)
c = c*100+sbackc(q);
if(c >= MAXIND) {
error("index too big\n");
}
release(q);
n = getstk() & 0377;
sptr = stable[n];
if(sptr != 0){
p = sptr->val;
if(length(p)-PTRSZ >= c*PTRSZ) {
seekc(p,c*PTRSZ);
s = dcgetwd(p);
if(s != 0) {
q = copy(s,length(s));
pushp(q);
continue;
}
}
}
q = salloc(1); /*so uninitialized array elt prints as 0*/
sputc(q, 0);
pushp(q);
continue;
case 'x':
execute:
p = pop();
EMPTY;
if((readptr != &readstk[0]) && (*readptr != 0)) {
if((*readptr)->rd == (*readptr)->wt)
release(*readptr);
else {
if(readptr++ == &readstk[RDSKSZ]) {
error("nesting depth\n");
}
}
} else
readptr++;
*readptr = p;
if(p != 0)
rewind(p);
else {
if((c = readc()) != '\n')
unreadc(c);
}
continue;
case '?':
if(++readptr == &readstk[RDSKSZ]) {
error("nesting depth\n");
}
*readptr = 0;
fsave = curfile;
curfile = &bin;
while((c = readc()) == '!')
command();
p = salloc(0);
sputc(p,c);
while((c = readc()) != '\n') {
sputc(p,c);
if(c == '\\')
sputc(p,readc());
}
curfile = fsave;
*readptr = p;
continue;
case '!':
if(command() == 1)
goto execute;
continue;
case '<':
case '>':
case '=':
if(cond(c) == 1)
goto execute;
continue;
default:
Bprint(&bout,"%o is unimplemented\n",c);
}
}
}
void
commnds(void){
register int c;
register struct blk *p,*q;
long l;
int sign;
struct blk **ptr,*s,*t;
struct sym *sp;
int sk,sk1,sk2;
int n,d;
while(1){
if(((c = readc())>='0' && c <= '9')|| (c>='A' && c <='F') || c == '.'){
unreadc(c);
p = readin();
pushp(p);
continue;
}
switch(c){
case ' ':
case '\n':
case 0377:
case EOF:
continue;
case 'Y':
sdump("stk",*stkptr);
printf("all %ld rel %ld headmor %ld\n",all,rel,headmor);
printf("nbytes %ld\n",nbytes);
continue;
case '_':
p = readin();
savk = sunputc(p);
chsign(p);
sputc(p,savk);
pushp(p);
continue;
case '-':
subt();
continue;
case '+':
if(eqk() != 0)continue;
binop('+');
continue;
case '*':
arg1 = pop();
EMPTY;
arg2 = pop();
EMPTYR(arg1);
sk1 = sunputc(arg1);
sk2 = sunputc(arg2);
binop('*');
p = pop();
sunputc(p);
savk = n = sk1+sk2;
if(n>k && n>sk1 && n>sk2){
sk = sk1;
if(sk<sk2)sk = sk2;
if(sk<k)sk = k;
p = removc(p,n-sk);
savk = sk;
}
sputc(p,savk);
pushp(p);
continue;
case '/':
casediv:
if(dscale() != 0)continue;
binop('/');
if(irem != 0)release(irem);
release(rem);
continue;
case '%':
if(dscale() != 0)continue;
binop('/');
p = pop();
release(p);
if(irem == 0){
sputc(rem,skr+k);
pushp(rem);
continue;
}
p = add0(rem,skd-(skr+k));
q = add(p,irem);
release(p);
release(irem);
sputc(q,skd);
pushp(q);
continue;
case 'v':
p = pop();
EMPTY;
savk = sunputc(p);
if(length(p) == 0){
sputc(p,savk);
pushp(p);
continue;
}
if((c = sbackc(p))<0){
error("sqrt of neg number\n");
}
if(k<savk)n = savk;
else{
n = k*2-savk;
savk = k;
}
arg1 = add0(p,n);
arg2 = dcsqrt(arg1);
sputc(arg2,savk);
pushp(arg2);
continue;
case '^':
neg = 0;
arg1 = pop();
EMPTY;
if(sunputc(arg1) != 0)error("exp not an integer\n");
arg2 = pop();
EMPTYR(arg1);
if(sfbeg(arg1) == 0 && sbackc(arg1)<0){
neg++;
chsign(arg1);
}
if(length(arg1)>=3){
error("exp too big\n");
}
savk = sunputc(arg2);
p = dcexp(arg2,arg1);
release(arg2);
rewind(arg1);
c = sgetc(arg1);
if(sfeof(arg1) == 0)
c = sgetc(arg1)*100 + c;
d = c*savk;
release(arg1);
if(neg == 0){
if(k>=savk)n = k;
else n = savk;
if(n<d){
q = removc(p,d-n);
sputc(q,n);
pushp(q);
}
else {
sputc(p,d);
pushp(p);
}
}
else {
sputc(p,d);
pushp(p);
}
if(neg == 0)continue;
p = pop();
q = salloc(2);
sputc(q,1);
sputc(q,0);
pushp(q);
pushp(p);
goto casediv;
case 'z':
p = salloc(2);
n = stkptr - stkbeg;
if(n >= 100){
sputc(p,n/100);
n %= 100;
}
sputc(p,n);
sputc(p,0);
pushp(p);
continue;
case 'Z':
p = pop();
EMPTY;
n = (length(p)-1)<<1;
fsfile(p);
sbackc(p);
if(sfbeg(p) == 0){
if((c = sbackc(p))<0){
n -= 2;
if(sfbeg(p) == 1)n += 1;
else {
if((c = sbackc(p)) == 0)n += 1;
else if(c > 90)n -= 1;
}
}
else if(c < 10) n -= 1;
}
release(p);
q = salloc(1);
if(n >= 100){
sputc(q,n%100);
n /= 100;
}
sputc(q,n);
sputc(q,0);
pushp(q);
continue;
case 'i':
p = pop();
EMPTY;
p = scalint(p);
release(inbas);
inbas = p;
continue;
case 'I':
p = copy(inbas,length(inbas)+1);
sputc(p,0);
pushp(p);
continue;
case 'o':
p = pop();
EMPTY;
p = scalint(p);
sign = 0;
n = length(p);
q = copy(p,n);
fsfile(q);
l = c = sbackc(q);
if(n != 1){
if(c<0){
sign = 1;
chsign(q);
n = length(q);
fsfile(q);
l = c = sbackc(q);
}
if(n != 1){
while(sfbeg(q) == 0)l = l*100+sbackc(q);
}
}
if (l > BC_BASE_MAX)
error("output base is too large\n");
logo = log_2(l);
obase = l;
release(basptr);
if(sign == 1)obase = (long)-l;
basptr = p;
outdit = (int (*)(struct blk *, int, int))bigot;
if(n == 1 && sign == 0){
if(c <= 16){
outdit = (int (*)(struct blk *, int, int))hexot;
fw = 1;
fw1 = 0;
ll = 68;
release(q);
continue;
}
}
n = 0;
if(sign == 1)n++;
p = salloc(1);
sputc(p,-1);
t = add(p,q);
n += length(t)*2;
fsfile(t);
if((c = sbackc(t))>9)n++;
release(t);
release(q);
release(p);
fw = n;
fw1 = n-1;
ll = 68;
if(fw>=ll)continue;
ll = (68/fw)*fw;
continue;
case 'O':
p = copy(basptr,length(basptr)+1);
sputc(p,0);
pushp(p);
continue;
case '[':
n = 0;
p = salloc(0);
while(1){
if((c = readc()) == ']'){
if(n == 0)break;
n--;
}
sputc(p,c);
if(c == '[')n++;
}
pushp(p);
continue;
case 'k':
p = pop();
EMPTY;
p = scalint(p);
if(length(p)>1){
error("scale too big\n");
}
rewind(p);
k = sfeof(p)?0:sgetc(p);
release(scalptr);
scalptr = p;
continue;
case 'K':
p = copy(scalptr,length(scalptr)+1);
sputc(p,0);
pushp(p);
continue;
case 'X':
p = pop();
EMPTY;
fsfile(p);
n = sbackc(p);
release(p);
p = salloc(2);
sputc(p,n);
sputc(p,0);
pushp(p);
continue;
case 'Q':
p = pop();
EMPTY;
if(length(p)>2){
error("Q?\n");
}
rewind(p);
if((c = sgetc(p))<0){
error("neg Q\n");
}
release(p);
while(c-- > 0){
if(readptr == &readstk[0]){
error("readstk?\n");
}
if(*readptr != 0)release(*readptr);
readptr--;
}
continue;
case 'q':
if(readptr <= &readstk[1])exit(0);
if(*readptr != 0)release(*readptr);
readptr--;
if(*readptr != 0)release(*readptr);
readptr--;
continue;
case 'f':
if(stkptr == &stack[0])printf("empty stack\n");
else {
for(ptr = stkptr; ptr > &stack[0];){
print(*ptr--);
}
}
continue;
case 'p':
if(stkptr == &stack[0])printf("empty stack\n");
else{
print(*stkptr);
}
continue;
case 'P':
p = pop();
EMPTY;
sputc(p,0);
printf("%s",p->beg);
release(p);
continue;
case 'd':
if(stkptr == &stack[0]){
printf("empty stack\n");
continue;
}
q = *stkptr;
n = length(q);
p = copy(*stkptr,n);
pushp(p);
continue;
case 'c':
while(stkerr == 0){
p = pop();
if(stkerr == 0)release(p);
}
continue;
case 'S':
if(stkptr == &stack[0]){
error("save: args\n");
}
c = readc() & 0377;
sptr = stable[c];
sp = stable[c] = sfree;
sfree = sfree->next;
if(sfree == 0)goto sempty;
sp->next = sptr;
p = pop();
EMPTY;
if(c >= ARRAYST){
q = copy(p,length(p));
for(n = 0;n < PTRSZ;n++)sputc(q,0);
release(p);
p = q;
}
sp->val = p;
continue;
sempty:
error("symbol table overflow\n");
case 's':
if(stkptr == &stack[0]){
error("save:args\n");
}
c = readc() & 0377;
sptr = stable[c];
if(sptr != 0){
p = sptr->val;
if(c >= ARRAYST){
rewind(p);
while(sfeof(p) == 0)release(dcgetwd(p));
}
release(p);
}
else{
sptr = stable[c] = sfree;
sfree = sfree->next;
if(sfree == 0)goto sempty;
sptr->next = 0;
}
p = pop();
sptr->val = p;
continue;
case 'l':
load();
continue;
case 'L':
c = readc() & 0377;
sptr = stable[c];
if(sptr == 0){
error("L?\n");
}
stable[c] = sptr->next;
sptr->next = sfree;
sfree = sptr;
p = sptr->val;
if(c >= ARRAYST){
rewind(p);
while(sfeof(p) == 0){
q = dcgetwd(p);
if(q != 0)release(q);
}
}
pushp(p);
continue;
case ':':
p = pop();
EMPTY;
q = scalint(p);
fsfile(q);
c = 0;
if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
error("neg index\n");
}
if(length(q)>2){
error("index too big\n");
}
if(sfbeg(q) == 0)c = c*100+sbackc(q);
if(c >= BC_DIM_MAX){
error("index too big\n");
}
release(q);
n = readc() & 0377;
sptr = stable[n];
if(sptr == 0){
sptr = stable[n] = sfree;
sfree = sfree->next;
if(sfree == 0)goto sempty;
sptr->next = 0;
p = salloc((c+PTRSZ)*PTRSZ);
zero(p);
}
else{
p = sptr->val;
if(length(p)-PTRSZ < c*PTRSZ){
q = copy(p,(c+PTRSZ)*PTRSZ);
release(p);
p = q;
}
}
seekc(p,c*PTRSZ);
q = lookwd(p);
if (q!=NULL) release(q);
s = pop();
EMPTY;
salterwd((struct wblk *)p,s);
sptr->val = p;
continue;
case ';':
p = pop();
EMPTY;
q = scalint(p);
fsfile(q);
c = 0;
if((sfbeg(q) == 0) && ((c = sbackc(q))<0)){
error("neg index\n");
}
if(length(q)>2){
error("index too big\n");
}
if(sfbeg(q) == 0)c = c*100+sbackc(q);
if(c >= BC_DIM_MAX){
error("index too big\n");
}
release(q);
n = readc() & 0377;
sptr = stable[n];
if(sptr != 0){
p = sptr->val;
if(length(p)-PTRSZ >= c*PTRSZ){
seekc(p,c*PTRSZ);
s = dcgetwd(p);
if(s != 0){
q = copy(s,length(s));
pushp(q);
continue;
}
}
}
q = salloc(1);
sputc(q, 0);
pushp(q);
continue;
case 'x':
execute:
p = pop();
EMPTY;
if((readptr != &readstk[0]) && (*readptr != 0)){
if((*readptr)->rd == (*readptr)->wt)
release(*readptr);
else{
if(readptr++ == &readstk[RDSKSZ]){
error("nesting depth\n");
}
}
}
else readptr++;
*readptr = p;
if(p != 0)rewind(p);
else{
if((c = readc()) != '\n')unreadc(c);
}
continue;
case '?':
if(++readptr == &readstk[RDSKSZ]){
error("nesting depth\n");
}
*readptr = 0;
fsave = curfile;
curfile = stdin;
while((c = readc()) == '!')command();
p = salloc(0);
sputc(p,c);
while((c = readc()) != '\n'){
sputc(p,c);
if(c == '\\')sputc(p,readc());
}
curfile = fsave;
*readptr = p;
continue;
case '!':
if(command() == 1)goto execute;
continue;
case '<':
case '>':
case '=':
if(cond(c) == 1)goto execute;
continue;
default:
printf("%o is unimplemented\n",c);
}
}
}
