/* This test script is part of GDB, the GNU debugger.
|
/* This test script is part of GDB, the GNU debugger.
|
|
|
Copyright 1999, 2002, 2003, 2004, 2005, 2006, 2007, 2008
|
Copyright 1999, 2002, 2003, 2004, 2005, 2006, 2007, 2008
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
*/
|
|
|
#include <iostream>
|
#include <iostream>
|
|
|
using namespace std;
|
using namespace std;
|
|
|
void marker1()
|
void marker1()
|
{
|
{
|
return;
|
return;
|
}
|
}
|
|
|
class A1 {
|
class A1 {
|
int x;
|
int x;
|
int y;
|
int y;
|
|
|
friend ostream& operator<<(ostream& outs, A1 one);
|
friend ostream& operator<<(ostream& outs, A1 one);
|
|
|
public:
|
public:
|
|
|
A1(int a, int b)
|
A1(int a, int b)
|
{
|
{
|
x=a;
|
x=a;
|
y=b;
|
y=b;
|
}
|
}
|
|
|
A1 operator+=(int value);
|
A1 operator+=(int value);
|
A1 operator+(const A1&);
|
A1 operator+(const A1&);
|
A1 operator-(const A1&);
|
A1 operator-(const A1&);
|
A1 operator%(const A1&);
|
A1 operator%(const A1&);
|
int operator==(const A1&);
|
int operator==(const A1&);
|
int operator!=(const A1&);
|
int operator!=(const A1&);
|
int operator&&(const A1&);
|
int operator&&(const A1&);
|
int operator||(const A1&);
|
int operator||(const A1&);
|
A1 operator<<(int);
|
A1 operator<<(int);
|
A1 operator>>(int);
|
A1 operator>>(int);
|
A1 operator|(const A1&);
|
A1 operator|(const A1&);
|
A1 operator^(const A1&);
|
A1 operator^(const A1&);
|
A1 operator&(const A1&);
|
A1 operator&(const A1&);
|
int operator<(const A1&);
|
int operator<(const A1&);
|
int operator<=(const A1&);
|
int operator<=(const A1&);
|
int operator>=(const A1&);
|
int operator>=(const A1&);
|
int operator>(const A1&);
|
int operator>(const A1&);
|
A1 operator*(const A1&);
|
A1 operator*(const A1&);
|
A1 operator/(const A1&);
|
A1 operator/(const A1&);
|
A1 operator=(const A1&);
|
A1 operator=(const A1&);
|
|
|
A1 operator~();
|
A1 operator~();
|
A1 operator+();
|
A1 operator+();
|
A1 operator-();
|
A1 operator-();
|
int operator!();
|
int operator!();
|
A1 operator++();
|
A1 operator++();
|
A1 operator++(int);
|
A1 operator++(int);
|
A1 operator--();
|
A1 operator--();
|
A1 operator--(int);
|
A1 operator--(int);
|
|
|
};
|
};
|
|
|
|
|
A1 A1::operator+(const A1& second)
|
A1 A1::operator+(const A1& second)
|
{
|
{
|
A1 sum(0,0);
|
A1 sum(0,0);
|
sum.x = x + second.x;
|
sum.x = x + second.x;
|
sum.y = y + second.y;
|
sum.y = y + second.y;
|
|
|
return (sum);
|
return (sum);
|
}
|
}
|
|
|
A1 A1::operator*(const A1& second)
|
A1 A1::operator*(const A1& second)
|
{
|
{
|
A1 product(0,0);
|
A1 product(0,0);
|
product.x = this->x * second.x;
|
product.x = this->x * second.x;
|
product.y = this->y * second.y;
|
product.y = this->y * second.y;
|
|
|
return product;
|
return product;
|
}
|
}
|
|
|
A1 A1::operator-(const A1& second)
|
A1 A1::operator-(const A1& second)
|
{
|
{
|
A1 diff(0,0);
|
A1 diff(0,0);
|
diff.x = x - second.x;
|
diff.x = x - second.x;
|
diff.y = y - second.y;
|
diff.y = y - second.y;
|
|
|
return diff;
|
return diff;
|
}
|
}
|
|
|
A1 A1::operator/(const A1& second)
|
A1 A1::operator/(const A1& second)
|
{
|
{
|
A1 div(0,0);
|
A1 div(0,0);
|
div.x = x / second.x;
|
div.x = x / second.x;
|
div.y = y / second.y;
|
div.y = y / second.y;
|
|
|
return div;
|
return div;
|
}
|
}
|
|
|
A1 A1::operator%(const A1& second)
|
A1 A1::operator%(const A1& second)
|
{
|
{
|
A1 rem(0,0);
|
A1 rem(0,0);
|
rem.x = x % second.x;
|
rem.x = x % second.x;
|
rem.y = y % second.y;
|
rem.y = y % second.y;
|
|
|
return rem;
|
return rem;
|
}
|
}
|
|
|
int A1::operator==(const A1& second)
|
int A1::operator==(const A1& second)
|
{
|
{
|
int a = (x == second.x);
|
int a = (x == second.x);
|
int b = (y == second.y);
|
int b = (y == second.y);
|
|
|
return (a && b);
|
return (a && b);
|
}
|
}
|
|
|
int A1::operator!=(const A1& second)
|
int A1::operator!=(const A1& second)
|
{
|
{
|
int a = (x != second.x);
|
int a = (x != second.x);
|
int b = (y != second.y);
|
int b = (y != second.y);
|
|
|
return (a || b);
|
return (a || b);
|
}
|
}
|
|
|
int A1::operator&&(const A1& second)
|
int A1::operator&&(const A1& second)
|
{
|
{
|
return ( x && second.x);
|
return ( x && second.x);
|
}
|
}
|
|
|
int A1::operator||(const A1& second)
|
int A1::operator||(const A1& second)
|
{
|
{
|
return ( x || second.x);
|
return ( x || second.x);
|
}
|
}
|
|
|
A1 A1::operator<<(int value)
|
A1 A1::operator<<(int value)
|
{
|
{
|
A1 lshft(0,0);
|
A1 lshft(0,0);
|
lshft.x = x << value;
|
lshft.x = x << value;
|
lshft.y = y << value;
|
lshft.y = y << value;
|
|
|
return lshft;
|
return lshft;
|
}
|
}
|
|
|
A1 A1::operator>>(int value)
|
A1 A1::operator>>(int value)
|
{
|
{
|
A1 rshft(0,0);
|
A1 rshft(0,0);
|
rshft.x = x >> value;
|
rshft.x = x >> value;
|
rshft.y = y >> value;
|
rshft.y = y >> value;
|
|
|
return rshft;
|
return rshft;
|
}
|
}
|
|
|
A1 A1::operator|(const A1& second)
|
A1 A1::operator|(const A1& second)
|
{
|
{
|
A1 abitor(0,0);
|
A1 abitor(0,0);
|
abitor.x = x | second.x;
|
abitor.x = x | second.x;
|
abitor.y = y | second.y;
|
abitor.y = y | second.y;
|
|
|
return abitor;
|
return abitor;
|
}
|
}
|
|
|
A1 A1::operator^(const A1& second)
|
A1 A1::operator^(const A1& second)
|
{
|
{
|
A1 axor(0,0);
|
A1 axor(0,0);
|
axor.x = x ^ second.x;
|
axor.x = x ^ second.x;
|
axor.y = y ^ second.y;
|
axor.y = y ^ second.y;
|
|
|
return axor;
|
return axor;
|
}
|
}
|
|
|
A1 A1::operator&(const A1& second)
|
A1 A1::operator&(const A1& second)
|
{
|
{
|
A1 abitand(0,0);
|
A1 abitand(0,0);
|
abitand.x = x & second.x;
|
abitand.x = x & second.x;
|
abitand.y = y & second.y;
|
abitand.y = y & second.y;
|
|
|
return abitand;
|
return abitand;
|
}
|
}
|
|
|
int A1::operator<(const A1& second)
|
int A1::operator<(const A1& second)
|
{
|
{
|
A1 b(0,0);
|
A1 b(0,0);
|
b.x = 3;
|
b.x = 3;
|
return (x < second.x);
|
return (x < second.x);
|
}
|
}
|
|
|
int A1::operator<=(const A1& second)
|
int A1::operator<=(const A1& second)
|
{
|
{
|
return (x <= second.x);
|
return (x <= second.x);
|
}
|
}
|
|
|
int A1::operator>=(const A1& second)
|
int A1::operator>=(const A1& second)
|
{
|
{
|
return (x >= second.x);
|
return (x >= second.x);
|
}
|
}
|
|
|
int A1::operator>(const A1& second)
|
int A1::operator>(const A1& second)
|
{
|
{
|
return (x > second.x);
|
return (x > second.x);
|
}
|
}
|
|
|
int A1::operator!(void)
|
int A1::operator!(void)
|
{
|
{
|
return (!x);
|
return (!x);
|
}
|
}
|
|
|
A1 A1::operator-(void)
|
A1 A1::operator-(void)
|
{
|
{
|
A1 neg(0,0);
|
A1 neg(0,0);
|
neg.x = -x;
|
neg.x = -x;
|
neg.y = -y;
|
neg.y = -y;
|
|
|
return (neg);
|
return (neg);
|
}
|
}
|
|
|
A1 A1::operator+(void)
|
A1 A1::operator+(void)
|
{
|
{
|
A1 pos(0,0);
|
A1 pos(0,0);
|
pos.x = +x;
|
pos.x = +x;
|
pos.y = +y;
|
pos.y = +y;
|
|
|
return (pos);
|
return (pos);
|
}
|
}
|
|
|
A1 A1::operator~(void)
|
A1 A1::operator~(void)
|
{
|
{
|
A1 acompl(0,0);
|
A1 acompl(0,0);
|
acompl.x = ~x;
|
acompl.x = ~x;
|
acompl.y = ~y;
|
acompl.y = ~y;
|
|
|
return (acompl);
|
return (acompl);
|
}
|
}
|
|
|
A1 A1::operator++() // pre increment
|
A1 A1::operator++() // pre increment
|
{
|
{
|
x = x +1;
|
x = x +1;
|
|
|
return (*this);
|
return (*this);
|
}
|
}
|
|
|
A1 A1::operator++(int) // post increment
|
A1 A1::operator++(int) // post increment
|
{
|
{
|
y = y +1;
|
y = y +1;
|
|
|
return (*this);
|
return (*this);
|
}
|
}
|
|
|
A1 A1::operator--() // pre decrement
|
A1 A1::operator--() // pre decrement
|
{
|
{
|
x = x -1;
|
x = x -1;
|
|
|
return (*this);
|
return (*this);
|
}
|
}
|
|
|
A1 A1::operator--(int) // post decrement
|
A1 A1::operator--(int) // post decrement
|
{
|
{
|
y = y -1;
|
y = y -1;
|
|
|
return (*this);
|
return (*this);
|
}
|
}
|
|
|
|
|
A1 A1::operator=(const A1& second)
|
A1 A1::operator=(const A1& second)
|
{
|
{
|
|
|
x = second.x;
|
x = second.x;
|
y = second.y;
|
y = second.y;
|
|
|
return (*this);
|
return (*this);
|
}
|
}
|
|
|
A1 A1::operator+=(int value)
|
A1 A1::operator+=(int value)
|
{
|
{
|
|
|
x += value;
|
x += value;
|
y += value;
|
y += value;
|
|
|
return (*this);
|
return (*this);
|
}
|
}
|
|
|
ostream& operator<<(ostream& outs, A1 one)
|
ostream& operator<<(ostream& outs, A1 one)
|
{
|
{
|
return (outs << endl << "x = " << one.x << endl << "y = " << one.y << endl << "-------" << endl);
|
return (outs << endl << "x = " << one.x << endl << "y = " << one.y << endl << "-------" << endl);
|
}
|
}
|
|
|
class A2 {
|
class A2 {
|
public:
|
public:
|
A2 operator+();
|
A2 operator+();
|
};
|
};
|
|
|
A2 A2::operator+()
|
A2 A2::operator+()
|
{
|
{
|
return A2 ();
|
return A2 ();
|
}
|
}
|
|
|
class Member
|
class Member
|
{
|
{
|
public:
|
public:
|
int z;
|
int z;
|
};
|
};
|
|
|
class Container
|
class Container
|
{
|
{
|
public:
|
public:
|
Member m;
|
Member m;
|
|
|
Member& operator* ();
|
Member& operator* ();
|
};
|
};
|
|
|
Member& Container::operator* ()
|
Member& Container::operator* ()
|
{
|
{
|
return this->m;
|
return this->m;
|
}
|
}
|
|
|
int main (void)
|
int main (void)
|
{
|
{
|
A1 one(2,3);
|
A1 one(2,3);
|
A1 two(4,5);
|
A1 two(4,5);
|
A1 three(0,0);
|
A1 three(0,0);
|
Container c;
|
Container c;
|
int val;
|
int val;
|
|
|
marker1(); // marker1-returns-here
|
marker1(); // marker1-returns-here
|
cout << one; // marker1-returns-here
|
cout << one; // marker1-returns-here
|
cout << two;
|
cout << two;
|
three = one + two;
|
three = one + two;
|
cout << "+ " << three;
|
cout << "+ " << three;
|
three = one - two;
|
three = one - two;
|
cout << "- " << three;
|
cout << "- " << three;
|
three = one * two;
|
three = one * two;
|
cout <<"* " << three;
|
cout <<"* " << three;
|
three = one / two;
|
three = one / two;
|
cout << "/ " << three;
|
cout << "/ " << three;
|
three = one % two;
|
three = one % two;
|
cout << "% " << three;
|
cout << "% " << three;
|
three = one | two;
|
three = one | two;
|
cout << "| " <<three;
|
cout << "| " <<three;
|
three = one ^ two;
|
three = one ^ two;
|
cout << "^ " <<three;
|
cout << "^ " <<three;
|
three = one & two;
|
three = one & two;
|
cout << "& "<< three;
|
cout << "& "<< three;
|
|
|
val = one && two;
|
val = one && two;
|
cout << "&& " << val << endl << "-----"<<endl;
|
cout << "&& " << val << endl << "-----"<<endl;
|
val = one || two;
|
val = one || two;
|
cout << "|| " << val << endl << "-----"<<endl;
|
cout << "|| " << val << endl << "-----"<<endl;
|
val = one == two;
|
val = one == two;
|
cout << " == " << val << endl << "-----"<<endl;
|
cout << " == " << val << endl << "-----"<<endl;
|
val = one != two;
|
val = one != two;
|
cout << "!= " << val << endl << "-----"<<endl;
|
cout << "!= " << val << endl << "-----"<<endl;
|
val = one >= two;
|
val = one >= two;
|
cout << ">= " << val << endl << "-----"<<endl;
|
cout << ">= " << val << endl << "-----"<<endl;
|
val = one <= two;
|
val = one <= two;
|
cout << "<= " << val << endl << "-----"<<endl;
|
cout << "<= " << val << endl << "-----"<<endl;
|
val = one < two;
|
val = one < two;
|
cout << "< " << val << endl << "-----"<<endl;
|
cout << "< " << val << endl << "-----"<<endl;
|
val = one > two;
|
val = one > two;
|
cout << "> " << val << endl << "-----"<<endl;
|
cout << "> " << val << endl << "-----"<<endl;
|
|
|
three = one << 2;
|
three = one << 2;
|
cout << "lsh " << three;
|
cout << "lsh " << three;
|
three = one >> 2;
|
three = one >> 2;
|
cout << "rsh " << three;
|
cout << "rsh " << three;
|
|
|
three = one;
|
three = one;
|
cout << " = "<< three;
|
cout << " = "<< three;
|
three += 5;
|
three += 5;
|
cout << " += "<< three;
|
cout << " += "<< three;
|
|
|
val = (!one);
|
val = (!one);
|
cout << "! " << val << endl << "-----"<<endl;
|
cout << "! " << val << endl << "-----"<<endl;
|
three = (+one);
|
three = (+one);
|
cout << "+ " << three;
|
cout << "+ " << three;
|
three = (-one);
|
three = (-one);
|
cout << "- " << three;
|
cout << "- " << three;
|
three = (~one);
|
three = (~one);
|
cout << " ~" << three;
|
cout << " ~" << three;
|
three++;
|
three++;
|
cout << "postinc " << three;
|
cout << "postinc " << three;
|
three--;
|
three--;
|
cout << "postdec " << three;
|
cout << "postdec " << three;
|
|
|
--three;
|
--three;
|
cout << "predec " << three;
|
cout << "predec " << three;
|
++three;
|
++three;
|
cout << "preinc " << three;
|
cout << "preinc " << three;
|
|
|
(*c).z = 1;
|
(*c).z = 1;
|
|
|
return 0;
|
return 0;
|
|
|
}
|
}
|
|
|
