Microsoft Patents 'IsNot', Enlists WTO

  <http://images.slashdot.org/slc.gif>  <http://yro.slashdot.org/> Your
Rights Online: Microsoft Patents 'IsNot', Enlists WTO	
 <http://slashdot.org/search.pl?topic=155> Patents
	
Posted by michael <http://slashdot.org/>  on Friday November 19, @09:43AM
from the sigh dept.
Milhouse102 <mailto:me@milhouse.co.uk>  writes "I was just reading an
article on The Register about Microsoft's
<http://www.theregister.co.uk/2004/11/19/microsoft_wto_winning_without_firin
g/> offshore patent war following Ballmer's recent outburst in Asia. I came
across this little nugget, it seems MS
<http://appft1.uspto.gov/netacgi/nph-Parser?Sect1=PTO1&Sect2=HITOFF&d=PG01&p
=1&u=%2Fnetahtml%2FPTO%2Fsrchnum.html&r=1&f=G&l=50&s1=%2220040230959%22.PGNR
.&OS=DN/20040230959&RS=DN/20040230959> has patented BASIC's IsNot operator."



(  <http://yro.slashdot.org/yro/04/11/19/1426256.shtml?tid=155&tid=109> Read
More... | 400
<http://yro.slashdot.org/yro/04/11/19/1426256.shtml?tid=155&tid=109>  of 524
<http://yro.slashdot.org/article.pl?sid=04/11/19/1426256&threshold=-1&tid=15
5&tid=109>  comments | yro.slashdot.org <http://yro.slashdot.org/>  )

http://appft1.uspto.gov/netacgi/nph-Parser?Sect1=PTO1
<http://appft1.uspto.gov/netacgi/nph-Parser?Sect1=PTO1&Sect2=HITOFF&d=PG01&p
=1&u=%2Fnetahtml%2FPTO%2Fsrchnum.html&r=1&f=G&l=50&s1=%2220040230959%22.PGNR
.&OS=DN/20040230959&RS=DN/20040230959>
&Sect2=HITOFF&d=PG01&p=1&u=%2Fnetahtml%2FPTO%2Fsrchnum.html&r=1&f=G&l=50&s1=
%2220040230959%22.PGNR.&OS=DN/20040230959&RS=DN/20040230959


United States Patent Application	 20040230959 	
Kind Code 	A1 	
Vick, Paul A. JR. ;   et al. 	November 18, 2004 	

  _____  

IS NOT OPERATOR 



Abstract

A system, method and computer-readable medium support the use of a single
operator that allows a comparison of two variables to determine if the two
variables point to the same location in memory. 

What is claimed: 

1. A system for determining if two operands point to different locations in
memory, the system comprising: a compiler for receiving source code and
generating executable code from the source code, the source code comprising
an expression comprising an operator associated with a first operand and a
second operand, the expression evaluating to true when the first operand and
the second operand point to different memory locations. 

2. The system of claim 1, wherein the compiler is a BASIC-derived
programming language compiler. 

3. The system of claim 1, wherein the operator is IsNot. 

4. The system of claim 1, wherein the compiler comprises a scanner, a
parser, an analyzer and an executable-generator. 

5. The system of claim 4, wherein the source code comprises at least one
statement, and the statement comprises a keyword representing the operator,
the keyword recognized by the scanner. 

6. The system of claim 5, wherein the parser receives the scanned source
code from the scanner and determines if the operator is preceded by and
followed by an operand. 

7. The system of claim 6, wherein in response to determining that the
operator is not preceded by and followed by an operand, an error message is
generated. 

8. The system of claim 6, wherein the parsed source code is received by the
analyzer, the analyzer evaluating the parsed code to determine if the
preceding operand evaluates to a pointer. 

9. The system of claim 8, wherein an error message is generated in response
to the parser determining that the preceding operand is not a pointer. 

10. The system of claim 8, wherein the parsed source code is received by the
analyzer, the analyzer evaluating the parsed code to determine if the
following operand evaluates to a pointer. 

11. The system of claim 10, wherein an error message is generated in
response to the parser determining that the following operand is not a
pointer. 

12. The system of claim 10, wherein the generator receives the analyzed
source code from the analyzer and generates executable code from the
analyzed code for determining if the first operand and the second operand
point to different memory locations. 

13. The system of claim 12, wherein the executable code is executed and
returns a value of true if the first operand and the second operand point to
different memory locations and returns a value of false if the first operand
and the second operand point to the same memory location. 

14. The system of claim 12, wherein the generated executable code is a
non-device-specific intermediate code, capable of being executed by the
execution environment. 

15. A method for producing executable code for performing an object
non-equivalence comparison comprising: receiving source code comprising at
least one statement comprising a keyword representing a logical operator, a
first operand preceding the keyword and a second operand following the
keyword; and generating from the source code, executable code for evaluating
the statement to true if the first operand and the second operand point to
different locations in memory and to false if the first operand and the
second operand point to the same locations in memory. 

16. The method of claim 15, further comprising: scanning the source code to
recognize the keyword. 

17. The method of claim 16, further comprising: parsing the scanned source
code to determine that the keyword is preceded by a first operand that
represents a class and followed by a second operand that represents a class.


18. The method of claim 17, further comprising: evaluating the parsed source
code to determine that the first operand and second operand are pointers. 

19. The method of claim 18, wherein executable code for performing an object
non-equivalence comparison is generated from the evaluated code. 

20. The method of claim 15 wherein the source code is BASIC code. 

21. A computer-readable medium comprising computer-executable instructions
for: receiving source code comprising at least one statement comprising a
keyword representing a logical operator, and a first operand and a second
operand; and generating from the source code, executable code for the at
least one statement, the executable code evaluating to true when the first
operand points to a first location in memory and the second operand points
to a second location in memory that is different from the first location in
memory, the at least one statement evaluating to false when the first
operand and the second operand point to the same location in memory. 

22. The computer-readable medium of claim 21, comprising further
instructions for: scanning the source code to recognize the keyword. 

23. The computer-readable medium of claim 22, comprising further
instructions for: parsing the scanned source code to determine that the
keyword is preceded by a first operand that represents a class and followed
by a second operand that represents a class. 

24. The computer-readable medium of claim 23, comprising further
instructions for: evaluating the parsed source code to determine that the
first operand and second operand are pointers.