Calvin Hsia's WebLog : Programming

Comment/Uncomment code to switch versions quickly without using macros

Calvin_Hsia — Sat, 28 Mar 2009 09:39:00 GMT

In a typical day, I write or debug programs in several languages: typically Foxpro, C#, VB, C++ and 32 bit assembly, with an occasional MSIL, IDL and 64 bit ASM thrown in.

Sometimes, I like to switch between one version of code and another. This is useful if I want to do side by side comparisons of behavior.

One way to do this is with preprocessor macros, like this:

#If SomeValue

#else

#endif

However, that’s a fair amount of typing.

There’s a shortcut that works with C# and C++ style comments.

In these languages, a line that starts with “//” is a comment.

Also, a block comment (which can span multiple lines) starts with “/*” and ends with “*/”

//*

int sub foo1() {

int x = 2;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo1

return x;

}

/*/

int sub foo2() {

int x = 3;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo2

return x;

}

// */

With a single character change I can switch between foo1 and foo2: just delete the very first “/”. That changes the single line comment into a block comment. The “*/” of the “/*/” now acts like the end of the comment block.

Using an editor that colors the code (like Visual Studio) shows the switch properly

int sub foo1() {

int x = 2;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo1

return x;

}

/*/

int sub foo2() {

int x = 3;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo2

return x;

}

// */

This technique is useful when creating sample code for others to play with, such as in my next blog post.

Make your code more maintainable: The evils of the Return statement

Calvin_Hsia — Tue, 29 Jul 2008 00:34:00 GMT

What does it mean to make code more maintainable? Certainly obfuscated code is hard to understand, by definition.

A big part of maintainability is making it easier for others to read and understand what the code is doing. Your code may have been working for years, but then somebody comes along and wants to add a feature, which might break your code.

Sometimes the behavior of code isn’t quite right, so you might need to investigate somebody else’s code.

(The repro scenario of the issue might be quite complicated, involving several tedious minutes of (perhaps ambiguous) keystrokes and clicks.

You might be single stepping some code, and suddenly you find yourself past the point where something seems to have gone wrong. <Sigh>. You have to restart the entire scenario, putting a breakpoint before the offending code is executed. Or do you? Set Next Statement is your friend. Often you can use Set Next Statement to go back a bit. You can perhaps modify some local variables and try to execute the code again, without having to repeat the tedious repro scenario.)

The Return statement exists in many languages, including C#, VB, FoxPro, C++. This discussion pertains to all of them.

Each of these languages allow you to create a very complex expression, perhaps with inline conditionals, precede it with the keyword “Return” and the value of the expression is the return value of the current method.

Suppose you had “simple” functions Foo and Bar:

int Foo(someparam)

{

return Bar(someparam)->SomeMethod(SomeOtherParam);

}

int Bar(someparam)

{

<...some code...>

return AnotherFoo(SomeFunc(SomeOtherValue));

}

Another return statement sample with 20 calls in it:

return (HasFlag(Flags, GetSomeVal(Flags)) &&

!HasFlag32(Result, SXF_LPE) &&

!(IsSomeValPointer(Result) &&

// Rule out Pointers to values of types.

!(Result->AsSomeValPointerExpression().Left->type == type_WRD &&

Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer &&

!HasFlag32(Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer, SXF_LWORD) &&

ValHelpers::IsValue(Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer->ResultType)&&

// make sure SomeSomeVal() still works for value types(bug 32804)

!(Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer->type == type_SYM &&

Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer->AsWordPointerExpression().Word->PVariable()->IsGood()))))

Suppose you’re debugging a program and single stepping and reach the end of Bar(). Even after stepping over this statement, you can’t easily see the value (or intermediate values) that’s being returned. You can’t even see the type of the return value unless you can see the method signature on the screen: “Function MyMethod() As SomeType”

The Autos window does show the return value/type for native code, (but not VB or C#), but I find that the other info it displays is useless. It tries to guess the nearby values that you might want to see: I much prefer the Locals window. It would be nice if the return value from the Autos window were displayed in the Locals window. So I’ve resorted to showing just the top couple of lines of the Auto window under my Locals window. However, the Autos window doesn’t allow you to change a returned value, whereas the Locals window does.

Also, seeing intermediate values by hovering your mouse works for local values, but not for method calls.

(If you’re debugging C++ code, then if you open the Debug->Windows->Registers window, you can see and change simple return values like Bools and Integers in the EAX register (32 bit) or RAX (64 bit), but watch out for implied destructor calls)

So you step out of the function Bar(), then you’re on another complex return statement in Foo(), where you still can’t see the returned value. So you step out again, and yet another Return statement. You might need to step out a few levels before you can see what the value is. If you want to reexamine this path, you can Set Next Statement back, but then you’re at a call stack level that’s far from the original code, so you have to go drill back down the callstack.

Now suppose you think the return value of Bar() isn’t quite right, or you want to reexamine what is happening.

Right click and choose “Step Into Specific” ,which might list 20 different functions into which you could step. However, depending on conditionals and prior values, not all of the 20 may be called. So you Step into the first, see that it’s uninteresting, Step into the Next, etc. until you see something interesting.

(look for a future blog post on Just My Code for native debugging that will remove a lot of the uninteresting Step Intos., like library or template functions or operator overloads)

So we’ve discussed two maintainability issues:

· make the return value of your function more visible while debugging, so the user can verify functionality more easily and can use Set Next Statement.

· Break up complex expressions, especially in Return statements.

The simple solution to both of these issues: Introduce new local variables to have intermediate results and break up nested conditional clauses to be separate If statements.

· Set Next Statement and Breakpoint granularity is finer.

· Intermediate results can be seen and modified in the Locals window

· Mouse hover shows the values

· The local variable names can be further indications of intent.

Simply changing the code from:

Return <ComplexExpr>

Int RetVal = <ComplexExpr>

Return RetVal

will make a huge difference in this debugging scenario. The user can Step Over and the RetVal can be seen in the debugger and, if it’s wrong, the user can Set Next Statement back and reexecute the code, Stepping In, rather than Stepping Over (watch out for side effects of reexecution). The user stays within the method without having to back up a few levels of the call stack. Also, it’s easier to see the type of the return value.

int Foo(someparam)

{

SomeType Barval = Bar(somparam);

Int RetVal = Barval->SomeMethod(SomeOtherParam);

return Retval;

}

int Bar(someparam)

{

<...some code...>

SomeFuncType SomeFuncVal = SomeFunc(SomeOtherValue));

Int Retval = AnotherFoo(SomeFuncVal);

return Retval;

}

Modern optimizing compilers can optimize out those variables and can generate identical code.

I once heard of a chess program written in one (very long) line of code, but imagine trying to maintain that puppy!

Use a dictionary to help create a mnemonic

Calvin_Hsia — Fri, 06 Jun 2008 22:36:00 GMT

I was using a program that was yet another TLA and I wanted to create a mnemonic to help me remember what it was. One of the letters was “k”, so I wanted to find a word that starts with “k”

Simple: load a dictionary, search for words starting with “k” and browse through them: “Killer” sounded fine!

The Dictionary dll (that you can download from the link below) actually contains 2 separate dictionaries in 679k bytes! The big one (Dictnum=1) has 171,201 words. The smaller (DictNum=2) has 53,869. These dictionaries are spelling dictionaries from the last century.

The samples below also demonstrate a simple LINQ query on the data:

I wanted to use common words, so I used the smaller one.

Fox code:

x=CREATEOBJECT("dictionary.dict")

x.Dictnum=2 && small dictionary

?x.FindMatches("k*")

cnt=x.words.count

CREATE CURSOR words (word c(20))

FOR i = 0 TO cnt-1

?x.Words.Item(i)

INSERT INTO words (word) VALUES (x.words.item(i))

ENDFOR

SELECT * FROM words WHERE AT("ill",word)>0

For VB code, Start VS, File->New->Project->VB->WindowsApplication->Console Application

We don’t have to reference the DLL (unless you want intellisense or use queries directly on the word collection) because late binding works.

(Since the DLL is 32 bit, if you’re using a 64 bit OS, make sure you make Project->Properties->Compile->Advanced Compiler Settings->Target CPU x86)

Module Module1

Sub Main()

Dim x = CreateObject("dictionary.dict")

'Dim x = New Dictionary.CDict ' use early binding: add a ref to Dictionary 1.0 Type Library

x.DictNum = 2 ' small dictionary

x.FindMatches("k*")

Dim col As New List(Of String) ' for late bindinq queries, we'll add to a list

For Each word In x.words

Debug.WriteLine(word)

col.Add(word)

For Each word In From a In col Where a.Contains("ill")

Debug.WriteLine(word)

End Sub

End Module

For C#, add a reference to “Dictionary 1.0 Type Library” in the COM tab.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

class Program

{

static void Main(string[] args)

{

var x = new Dictionary.CDictClass();

x.DictNum = 2;

x.FindMatches("k*");

foreach (var word in x.Words)

{

System.Diagnostics.Debug.WriteLine(word);

}

var q = from string a in x.Words where a.Contains("ill") select a;

foreach (var w in q)

{

System.Diagnostics.Debug.WriteLine(w);

}

Download the dictionary from here: A Discounter Introduces Reductions: Multiple Anagrams

You can create many word related games.

More word games:

Write your own hangman game

The Nametag Game

Create your own typing tutor!

Carburetor is a car part, but prosecutable is not

What mnemonic can you create from your phone number? See Phone Number Challenge update

How to interrupt your code

Calvin_Hsia — Fri, 16 May 2008 05:42:00 GMT

I received a question:

Simply, is there a way of interrupting a vfp sql query once it has started short of closing down the process ?

I am running some complex queries on very large datasets which can sometimes take many minutes to complete.

Typically, a program that runs on your computer has a main thread of execution.

On this thread, the processor is fetching instructions from memory and executing them. If this thread is busy, perhaps executing a query, or even just in a loop, the processor won’t check for user input.

Imagine the processor to be a person working in a factory. If she’s busy, then she doesn’t have time to look at her email. One way to fix this is to add an item to her workload to look at the email once in a while. If she’s in a loop (repetitive work), then adding an item in the loop would work.

Another way to fix this is to have another person (thread) in the factory. His job is to watch the email for any pending requests. He has the ability to interrupt her work.

Many applications are single threaded. That means there is only one person responsible for doing the work, listening for input, and updating the User Interface. Sometimes he’s very busy, so to the user, the application seems non-responsive.

As above, a solution is to create another thread (think of it as adding another person who can help do the work). This other thread can monitor the email.

The sample below creates a temporary table of many records. It then does a non-optimized Cartesian join of the table with itself, making the main thread busy.

The Set Escape command tells the main thread to check for the Escape key (looking for the boss at the door).

The On Escape command says what to do if the boss is there.

As an alternative, you can inject your own code into the work loop. The WasKeyPressed function, for example, checks for a keypress.

If work is interrupted, the worker may not have finished the current task, perhaps leaving the environment in an abnormal state.

See also other threading samples, which allow you to create multiple threads in VB and FoxPro

Use Visual Studio Test framework to create tests for your code

Sample program to create multiple threads

Create multiple threads from within your application

More Multithread capabilities: interthread synchronization, error checking

Webcrawl a blog to retrieve all entries locally: RSS on steroids

The VB version of the Blog Crawler

CLEAR ALL

CLEAR

MODIFY COMMAND PROGRAM() NOWAIT

CREATE CURSOR foo (name c(10))

INSERT INTO foo (name ) VALUES ("foo")

*Try with ESCAPE ON and OFF

SET ESCAPE ON

?"Escape=",SET("Escape")

ON ESCAPE do OnEscapeHandler

FOR i = 1 TO 12

APPEND FROM DBF("foo") && Double the size each iteration

ENDFOR

?"Reccount=",RECCOUNT()

?"query starting: try to stop it!"

ns=SECONDS()

TRY

* Cartesian product unoptimized join

SELECT * FROM foo, foo bar WHERE foo.name=bar.name INTO CURSOR results

* Sample that calls a method that checks for key press

* SELECT * FROM foo, foo bar WHERE foo.name=bar.name AND WasKeyPressed() INTO CURSOR results

CATCH TO ex

?"Caught",ex.Message,ex.Details,ex.UserValue

ENDTRY

?"Query done"

?SECONDS()-ns

RETURN

PROCEDURE OnEscapeHandler

?"Interrupted"

THROW "interrupted from "+PROGRAM()

RETURN

FUNCTION WasKeyPressed as Boolean

IF INKEY()>0

THROW "Key pressed from "+PROGRAM()

ENDIF

RETURN .T.

Examine .Net Memory Leaks

Calvin_Hsia — Fri, 11 Apr 2008 22:54:00 GMT

Writing programs using .Net is very productive. One reason is because much of memory management is “managed” for you. In C, C++ and other “native” languages, if you allocate memory, you’re responsible for freeing it. There were stopgap measures, like destructors, SmartPointers and reference counting, which helped, but were still cumbersome.

Foxpro manages memory for you, and has used garbage collection for decades: Heartbeat: Garbage collection in VFP and .NET are similar

However, you can still have memory leaks in .Net.

Try this in VS 2008: (I think it will work in 2005 too, can somebody verify? Thanks)

1. File->New->Project->VB Windows Console Application.

2. Paste the sample code below.

3. Project->Properties->Debug->Enable Unmanaged Code debugging

If you’re running 64 bit, you can force 32 bit targeting: Project->Properties->Compile->Advanced Compile Settings->Target CPU->x86 (see this for more about x64)

The sample code has a loop that creates and releases an instance of a class MyWatcher that uses the FileSystemWatcher class that reacts to events, such as files being created in a directory.

The class has a member (Dim MyLargeMemoryEater(100000) As String) which eats up 4 bytes (8 bytes on x64) per array element. At the end of each loop, the garbage collector is called to release everything. The class has a Finalize method that will be called when the garbage collector collects.

When you run the code, you see the increase in memory use in each loop. The increase per iteration is just a little more than the amount of memory used by MyLargeMemoryEater . Also, the Finalizers don’t run until the application is shutting down.

If you uncomment the “UnSubscribe” line, then the finalizer fires (on a different thread) and you can see the leak is gone.

Now let’s examine the leak by looking at the heap.

Make it leak, then put a breakpoint on the “Done” line after the loop. At this point, we suspect there are 100 instances of MyWatcher in the managed heap.

Wouldn’t it be great to see them? Let’s use SOS:

Open the Immediate window: Debug Menu->Windows-> Immediate window

Type in the lines in red

!load sos.dll

extension C:\Windows\Microsoft.NET\Framework\v2.0.50727\sos.dll loaded

!dumpheap -type MyWatcher

PDB symbol for mscorwks.dll not loaded

Address MT Size

02b7431c 000d313c 16

<…>

02bdc3f0 000d313c 16

02bdc550 000d313c 16

total 100 objects

Statistics:

MT Count TotalSize Class Name

000d313c 100 1600 ConsoleApplication1.MyWatcher

Total 100 objects

So now we know that there are 100 instances still around. Why were they not garbage collected? Because somebody has a reference to them. Choose one of the instances (02bdc550), and use the gcroot command:

!gcroot 02bdc550

Note: Roots found on stacks may be false positives. Run "!help gcroot" for

more info.

Error during command: Warning. Extension is using a callback which Visual Studio does not implement.

Scan Thread 6948 OSTHread 1b24

Scan Thread 536 OSTHread 218

Scan Thread 6448 OSTHread 1930

DOMAIN(00601068):HANDLE(AsyncPinned):b15b4:Root:02bdda44(System.Threading.OverlappedData)->

02bddf38(System.Threading.IOCompletionCallback)->

02bdcfc4(System.IO.FileSystemWatcher)->

02b8b14c(System.IO.FileSystemEventHandler)->

02bdc550(ConsoleApplication1.MyWatcher)

Now we see that the FileSystemWatcher is referencing us via an eventhandler.

(The “!dumpheap -stat” command is also very useful to see what’s on the heap)

Is this a Vista bug?

Calvin_Hsia — Thu, 19 Oct 2006 21:03:00 GMT

A customer reported a crash of a VFP application while running under the new version of Windows: Vista. The customer code attempted to automate the configuration of the web server (See Automating Web Site Administration Using IIS).

Specifically, there was a scenario under which the user code calling GETOBJECT("IIS://LOCALHOST/W3SVC/1/ROOT") would crash. At the time, the app was displaying a wizard which was a Fox form with some controls on it.

So I wrote some sample code (requires IIS to be installed on WinXP, and IIS with IIS 6 Metabase compatibility on Vista, as well as “Run As Administrator”) to try to reproduce the bug on Vista.

CLEAR

FOR i = 1 TO 10000

x=GETOBJECT("IIS://LOCALHOST/W3SVC/1/ROOT")

?i,x.defaultdoc

x=0

ENDFOR

Of course this worked flawlessly, so the customer sent me a zip file with a VFP runtime EXE that I could run on Vista to reproduce the error. Sure enough I could reproduce the crash. However, no crash occurred when the GETOBJECT line was single stepped under the VFP debugger.

Vista is shipping soon, so I need to figure out fast if this was a Vista bug.

After some debugging, I found why it was crashing. A ListBox on the form had the ColumnCount property set to 2, indicating to VFP that there should be 2 columns displayed. However, there was only one column defined in the RowSource property. In this case VFP wasn’t doing the right thing. Simple fix on the customer side: only one column was desired, so set the ColumnCount to 1. Simple fix on the VFP side: handle the case when the ColumnCount doesn’t match the number of items in the RowSource.

I came up with some code that repros the scenario in WinXP below. If you have 2 items in the RowSource, then it works fine. If not, it causes random behavior. In my case, I get “Variable '' is not found.”

Details: internally VFP maintains an Instruction Pointer (IP) that points to the next user code to execute. When executing the GETOBJECT line, it points to the code for that line. When evaluating a RowSource, the RowSource is compiled and the IP is pointed to the compiled code temporarily, then restored. The restoration was not happening if the number of items in the RowSource didn’t match the ColumnCount.

The reason it occurred on Vista was probably because WM_PAINT messages were sent to VFP to repaint the listbox while the GETOBJECT was executing. Perhaps the GETOBJECT was doing some waiting, which would cause some thread switches and idle time, allowing apps to paint. The IP was pointing at GETOBJECT, then the WM_PAINT caused the IP to point to some temporary place, then when the GETOBJECT was done, the IP was pointing at some random place to execute.

CLOSE DATABASES all

PUBLIC ox

ox=CREATEOBJECT("test")

DEFINE CLASS test as Form

left=200

AllowOutput=.f.

ADD OBJECT lst as ListBox

ADD OBJECT tmr as timer WITH interval=1000,enabled=.t.

PROCEDURE Load

CREATE CURSOR customer (Company c(10))

INSERT INTO customer VALUES ("One")

INSERT INTO customer VALUES ("Two")

PROCEDURE init

WITH this.lst as ListBox

.Width=300

.RowSourceType=2 && Alias

.RowSource="Customer.company+' asdf ' " && notice only 1 expression

* .RowSource="Customer.company+' asdf ',4 " && This is valid

.columncount=2

ENDWITH

this.show

PROCEDURE tmr.timer

?PROGRAM()

y=NEWOBJECT("form")

y.visible=1

y.windowstate=2

y=0

x=GETOBJECT("IIS://LOCALHOST/W3SVC/1/ROOT")

INKEY(.1)

ENDDEFINE

Write your own hangman game

Calvin_Hsia — Tue, 10 Oct 2006 03:26:00 GMT

Many years ago (1985) I wrote a C program to play Hangman. I had decoded a word processor spelling dictionary for my word source.

More recently, I have encoded 2 spelling dictionaries for general purpose use: 1 with 171201 words, the other with 53869. There’s some pretty serious compression to get them both into a 679,936 byte dll. That’s an average of 3 bytes per word!

This hangman doesn’t have much graphically, but it does keep your average score.

Fox and VB versions below:

Windows Security and how it affects running generated code

Calvin_Hsia — Thu, 10 Nov 2005 09:00:00 GMT

Here I described how VFP generates executable code and runs it for early and late binding COM clients and implementing COM interfaces. However, there is an important issue with generating and running executable code in the same process.

A computer has a processor (or a few) that fetches instructions from memory and executes them. Some of the instructions refer to other areas of memory. The Operating System loads the memory initially. Various areas of memory are used for different purposes:

Code (the program)
Stack (for local variables and return addresses)
Heap
Initialized Data (like constants)
Uninitialized Data (like an uninitialized static array)

It gets a little more complicated with multiple DLLs each of which may have its own code/data sections, and threads, each of which will have its own stack, but we’ll ignore this for now.

Certain areas of memory will remain constant for the process lifetime, such as the code. Other areas will change dynamically, such as the stack and the heap. The CPU will fetch instructions only through the Instruction Pointer.

The NX feature prevents code from running from non-code marked pages of memory, so if the IP points to an NX area of memory, an exception is thrown. Certain viruses and worms cause execution of code from the stack or heap, so this prevents certain kinds of malicious attacks.

The generated machine code for VFP COM servers and implemented interfaces lives in heap memory, so the IP will be fetching instructions from the heap.

(This feature is called NX (No Execute) on AMD machines, XD (Execute Disable) by Intel, and DEP (Data Execution Prevention) on Windows Server 2003 and I believe, WinXP SP2. Does anyone see this feature on WinXPSP2?)

To test this, I installed VFP8 and VFP9 (RTM) on an AMD64 machine running Windows Server 2003 SP1. Right click on My Computer, select Properties->Advanced->Performance Settings->Data Execution Prevention->Turn on DEP for all programs and services except those I select:

Then I built my universal COM server below (which is used to run my website, by the way) and tested it. On a WinXP machine, the code runs fine, with both early and late bound calls succeeding. If I use CREATEOBJECTEX to create an object which will be accessed via early binding, I can use GETINTERFACE to get the IDispatch interface to call it via late binding. Conversely, an object that is created via CREATEOBJECT will be accessed by late binding, but I can use GETINTERFACE to get its early bound interface

On the AMD machine with DEP enabled, VFP8 caused an Access Violation (see What is a C0000005 crash?) for the early bound calls, but VFP9 worked just fine. Why? Because generated executable code in VFP9 now gets put into a memory page marked with the PAGE_EXECUTE_READWRITE flag.

If your application invites any other 3^rd party code into the process space (such as ActiveX controls, COM servers, DECLARE DLL, Load/Call or a SET LIBRARY TO) and you are getting unexpected errors, it may be due to this NX feature.

These articles go into a lot more detail: http://en.wikipedia.org/wiki/NX_bit

A detailed description of the Data Execution Prevention (DEP) feature in Windows XP Service Pack 2, Windows XP Tablet PC Edition 2005, and Windows Server 2003

* A universal COM server

TEXT TO tempvar NOSHOW

DEFINE CLASS c1 as session olepublic

proc MyDoCmd(cCmd as string,p2 as Variant,p3 as Variant,p4 as Variant,p5 as Variant) helpstring 'Execute a command'

&cCmd

proc MyEval(cExpr as string,p2 as Variant,p3 as Variant,p4 as Variant,p5 as Variant) helpstring 'Evaluate an expression'

RETURN &cExpr

ENDDEFINE

ENDTEXT

STRTOFILE(tempvar,"c1.prg")

IF FILE("t1.dll") && unregister prior one

DECLARE integer DllUnregisterServer IN t1.dll

?"Unregister",DllUnregisterServer()

CLEAR DLLS

ENDIF

IF !FILE("t1.pjx") && the GUIDS are stored in the project, so to keep the same GUID, use the same PJX

BUILD PROJECT t1 FROM c1

ENDIF

BUILD MTDLL t1 FROM t1

*Test it:

ox=CREATEOBJECT("t1.c1") && create late bound object (IDispatch interface)

?ox.MyEval("_vfp.servername")

?"Late bound object with late bound call ",ox.MyEval("'EarlyLate='+sys(2334)")

oEarly = GETINTERFACE(ox,"IC1")

?"Late bound object with early bound call ",oEarly.MyEval("'EarlyLate='+sys(2334)")

CLEAR ALL

oEarly=CREATEOBJECTEX("t1.c1","","") && create early bound object (IC1 interface)

?"Early bound object with early bound call",oEarly.MyEval("'EarlyLate='+sys(2334)")

oDisp=GETINTERFACE(oEarly,"IDispatch")

?"Early bound object with late bound call",oDisp.MyEval("'EarlyLate='+sys(2334)")

Do you know everything about Factorials?

Calvin_Hsia — Mon, 24 Oct 2005 20:02:00 GMT

When I was in 7^th grade at Amity Junior High School in Orange Connecticut, I gave a presentation on Factorial numbers.

Here’s some interesting code:

FOR i = 1 TO 80

?i,Factorial(i),SQRT(2*PI()*i)*(i/EXP(1))^i

ENDFOR

PROCEDURE Factorial(n)

IF n=1

RETURN n

ENDIF

RETURN n*Factorial(n-1)

What do the base of natural logs (exp(1) = 2.718281828…), PI (3.14159…) and the square root of 2 have to do with Factorial ?

(In case you were wondering, I did not include the transcendental math in my 7^th grade presentation)

I don’t know everything about the fascinating Factorials!

What is taking up the space on your hard disk? TreeMap it!

Calvin_Hsia — Sat, 18 Jun 2005 04:36:00 GMT

Several years ago, I saw a presentation from Microsoft Research about online communication in communities . In particular, a group was studying online communities based on NewsGroup message traffic volume. One of the results was a graphical view of the newsgroups called Netscan.

I didn’t think much of it til I received a comment on my blog Running out of space ? What's on your disk? in which I showed some code to put into a table the folders and their sizes on your hard disk. The comment pointed to a web site showing a Treemap to display disk space usage.

So, it was fairly easy to make a program that shows a map of my hard disk in a treemap. This is a sample treemap of my “c:\Program Files\” folder.

The treemap shows rectangles for each folder. Each rectangle is divided alternately horizontally or vertically, into subrectangles for each subfolder proportional in size to the folder. Hovering the mouse over a rectangle shows the folder path and size in a tooltip. The leftmost large block that takes the entire height shows that almost 1/3rd is taken up by Visual Studio 2003. The top left light blue large block is “Visual Studio 2003\vc7\atlmfc\lib” The next large vertical band is “Program Files\Common Files” with a couple speech engines and the one after is “Program Files\Microsoft Office”

A folder can contain files and folders. If a folder contains 5 subfolders and 10 files, it will have 6 subrectangles: 1 for each subfolder and 1 for the files (labeled with “*\” at the end)

Each folder is a MyRect object subclassed from Shape and added to the form, so there could be thousands of objects.

Try clicking on a folder: the MyRect Click event creates a new instance of the form drilling down one level deeper into that Rectangle.

The code to generate the Treemap (about 100 lines) in HTML is here and the raw prg is here. You can modify the code to add features delete folders that are right clicked on, use colors to show last used dates, show folder names on the rectangles, etc.

(Thanks to John Koziol for feedback on this code)

67877

Binding to Internet Explorer events: bug in Typelibrary

Calvin_Hsia — Wed, 18 May 2005 00:50:00 GMT

I was using the web browser control and getting some errors when binding to its events. This can be duplicated with the code below.

To generate the event class, open the object browser (Tools->Object Browser) and select the Microsoft Web Browser Control. Navigate to the DWebBrowserEvents2 interface and drag and drop it onto an open PRG editor window.

The object browser reads the interface definition from the type library for the chosen COM object and defines a class with the appropriate method signatures for you.

Then I added a couple lines to instantiate the web browser, the event class, and bind them together.

Running the code highlights the FileDownload method and gives the error: “Must specify additional parameters.”

Because this error is generated by an external object (IE) calling VFP, but before even reaching any VFP user code, a TRY/CATCH or error handler doesn’t help.

Further investigation showed that the FileDownload method of the DWebBrowserEvents2 interface shows that there is one parameter specified in the Type library.

[id(0x0000010e), helpstring("Fired to indicate the File Download dialog is opening")]

void FileDownload([in, out] VARIANT_BOOL* Cancel);

However, IE is calling with 2 parameters. The MSDN documentation for this method shows 2 parameters:

void FileDownload(

    VARIANT_BOOL *&ActiveDocument,

    VARIANT_BOOL *&Cancel

);

This KB article has more info. In particular, it states “any development tool that generates event handlers that are based on the type library cannot properly sink the event. “ The article itself has to do with .NET interop with the web browser control, so C# and VB.Net have the same problem.

Rick Strahl’s article also mentions this bug.

VFP internally reads the typelib and tries to match the number and type of parameters for each method. If the number of parameters aren’t exactly the same, VFP triggers an error message.

Perhaps a fix to this on the VFP side would be to relax the restriction that the number of parameters match exactly: just trigger an error if the number of parameters in the TypeLib is greater than the number defined in the VFP method. This change will allow the user to add more parameters to the implemented methods, which would fix this issue and also allow the method to be called internally with additional parameter(s).

oIe=CREATEOBJECT("internetexplorer.application")

oIe.visible=1

oEvents =NEWOBJECT("webEvents")

?EVENTHANDLER(oIE,oEvents)

oIe.navigate2("www.msn.com")

DEFINE CLASS webEvents AS custom

IMPLEMENTS DWebBrowserEvents2 IN "c:\windows\system32\shdocvw.dll"

PROCEDURE logit(cstr as String)

?cstr

PROCEDURE init

this.logit(PROGRAM())

PROCEDURE DWebBrowserEvents2_StatusTextChange(Text AS STRING) AS VOID;

HELPSTRING "Statusbar text changed."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_ProgressChange(Progress AS Number, ProgressMax AS Number) AS VOID;

HELPSTRING "Fired when download progress is updated."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_CommandStateChange(Command AS Number, Enable AS LOGICAL) AS VOID;

HELPSTRING "The enabled state of a command changed."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_DownloadBegin() AS VOID;

HELPSTRING "Download of a page started."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_DownloadComplete() AS VOID;

HELPSTRING "Download of page complete."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_TitleChange(Text AS STRING) AS VOID;

HELPSTRING "Document title changed."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_PropertyChange(szProperty AS STRING) AS VOID;

HELPSTRING "Fired when the PutProperty method has been called."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_BeforeNavigate2(pDisp AS VARIANT, URL AS VARIANT, Flags AS VARIANT, TargetFrameName AS VARIANT, PostData AS VARIANT, Headers AS VARIANT, Cancel AS LOGICAL @) AS VOID;

HELPSTRING "Fired before navigate occurs in the given WebBrowser (window or frameset element). The processing of this navigation may be modified."

this.logit(PROGRAM()+" "+url+" "+TRANSFORM(flags))

ENDPROC

PROCEDURE DWebBrowserEvents2_NewWindow2(ppDisp AS VARIANT @, Cancel AS LOGICAL @) AS VOID;

HELPSTRING "A new, hidden, non-navigated WebBrowser window is needed."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_NavigateComplete2(pDisp AS VARIANT, URL AS VARIANT) AS VOID;

HELPSTRING "Fired when the document being navigated to becomes visible and enters the navigation stack."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_DocumentComplete(pDisp AS VARIANT, URL AS VARIANT) AS VOID;

HELPSTRING "Fired when the document being navigated to reaches ReadyState_Complete."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_OnQuit() AS VOID;

HELPSTRING "Fired when application is quiting."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_OnVisible(Visible AS LOGICAL) AS VOID;

HELPSTRING "Fired when the window should be shown/hidden"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_OnToolBar(ToolBar AS LOGICAL) AS VOID;

HELPSTRING "Fired when the toolbar should be shown/hidden"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_OnMenuBar(MenuBar AS LOGICAL) AS VOID;

HELPSTRING "Fired when the menubar should be shown/hidden"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_OnStatusBar(StatusBar AS LOGICAL) AS VOID;

HELPSTRING "Fired when the statusbar should be shown/hidden"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_OnFullScreen(FullScreen AS LOGICAL) AS VOID;

HELPSTRING "Fired when fullscreen mode should be on/off"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_OnTheaterMode(TheaterMode AS LOGICAL) AS VOID;

HELPSTRING "Fired when theater mode should be on/off"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_WindowSetResizable(Resizable AS LOGICAL) AS VOID;

HELPSTRING "Fired when the host window should allow/disallow resizing"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_WindowSetLeft(Left AS Number) AS VOID;

HELPSTRING "Fired when the host window should change its Left coordinate"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_WindowSetTop(Top AS Number) AS VOID;

HELPSTRING "Fired when the host window should change its Top coordinate"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_WindowSetWidth(Width AS Number) AS VOID;

HELPSTRING "Fired when the host window should change its width"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_WindowSetHeight(Height AS Number) AS VOID;

HELPSTRING "Fired when the host window should change its height"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_WindowClosing(IsChildWindow AS LOGICAL, Cancel AS LOGICAL @) AS VOID;

HELPSTRING "Fired when the WebBrowser is about to be closed by script"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_ClientToHostWindow(CX AS Number @, CY AS Number @) AS VOID;

HELPSTRING "Fired to request client sizes be converted to host window sizes"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_SetSecureLockIcon(SecureLockIcon AS Number) AS VOID;

HELPSTRING "Fired to indicate the security level of the current web page contents"

this.logit(PROGRAM())

ENDPROC

* PROCEDURE DWebBrowserEvents2_FileDownload( Cancel AS LOGICAL @) AS VOID

PROCEDURE DWebBrowserEvents2_FileDownload(fActiveDoc as Logical @, Cancel AS LOGICAL @) AS VOID;

HELPSTRING "Fired to indicate the File Download dialog is opening"

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_NavigateError(pDisp AS VARIANT, URL AS VARIANT, Frame AS VARIANT, StatusCode AS VARIANT, Cancel AS LOGICAL @) AS VOID;

HELPSTRING "Fired when a binding error occurs (window or frameset element)."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_PrintTemplateInstantiation(pDisp AS VARIANT) AS VOID;

HELPSTRING "Fired when a print template is instantiated."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_PrintTemplateTeardown(pDisp AS VARIANT) AS VOID;

HELPSTRING "Fired when a print template destroyed."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_UpdatePageStatus(pDisp AS VARIANT, nPage AS VARIANT, fDone AS VARIANT) AS VOID;

HELPSTRING "Fired when a page is spooled. When it is fired can be changed by a custom template."

this.logit(PROGRAM())

ENDPROC

PROCEDURE DWebBrowserEvents2_PrivacyImpactedStateChange(bImpacted AS LOGICAL) AS VOID;

HELPSTRING "Fired when the global privacy impacted state changes"

this.logit(PROGRAM())

ENDPROC

ENDDEFINE

Third Party application does work as a COM+ application

Calvin_Hsia — Sat, 23 Apr 2005 01:40:00 GMT

A few months ago, I reported a problem that a customer was having with a particular 3^rd party product that seemed not to work with Visual FoxPro. It was a COM object that could be instantiated via CreateObject.

I was quite surprised that Windows guru Raymond Chen (author of the great blog: The Old New Thing) posted a comment within a few hours that pinpointed the problem in the code.

I mentioned that a workaround might be to put the product into a COM+ application, and that I couldn’t test it.

I just received email confirmation from another customer who had the same problem. They put the product into a COM+ application, and it indeed worked as expected with VFP.

I know how it feels when a fairly complex scenario doesn’t work as expected, but I am able to find a simple solution and workaround.

57992

Very Old Program

Calvin_Hsia — Fri, 15 Apr 2005 00:32:00 GMT

I was doing some spring cleaning and came across a computer printout of a program I wrote in August 1974, or about 31 years ago! That brings back a lot of memories. Coincidentally, a couple coworkers were discussing the CaSing of computer languages. What languages were in UPPER case, lower case, MiXed case, etc. This particular document was all upper case.

At the time, I was a Candy-Striper: a term for a volunteer at the Yale-New Haven hospital. I think the term refers to the red and white pin-striped frocks that were worn by the female volunteers. The prior summer I was a Candy-Striper in the Respiratory Therapy department, where I had to deal with IPPBs: Intermittent Positive Pressure Breathing machines. I wheeled them around the hospital and wash/sterilize them after each use. They were essentially breathing assistants: if they sensed that the patient started a breath, then more air would be forced into the lungs.

I figured I’d do something different in the summer before 11^th grade, so I worked with a population geneticist at Yale (in the same department where my dad worked as a geneticist). He basically wrote programs in PL/1 to analyze statistics to find patterns in genetic traits of people. But what was really great about working with him was that he had a terminal and an acoustic coupler (a 110 baud modem) with which we connected to the Yale Computer Center! It was an IBM Selectric terminal that had a type ball that would bounce up and down as it printed: it was fascinating to watch, and quite loud.

To use the modem, I’d pick up the handset, use the rotary dial to dial the number, wait for the high pitched screech, insert the handset into an acoustic coupler (basically a device that listened/output to the microphone/earphone of the handset), and wait for the handshaking process to finish indicated by “Enter Logon” from the type ball.

As part of the summer job, I got to go visit Yale Computer Center and use their IBM 370 which had a whopping 512 K of RAM. That’s half a megabyte!

In the computer center, there was a PDP-11 computer with a DPU (Display Processing Unit) that allowed fast calculation of vector graphics. I used to go there, insert the huge RK05 10 megabyte disk in the drive, and play a lunar lander game. There was a light pen for the monochromatic display with which you could control the rocket’s thrust and side rockets to try to guide the LEM (Lunar Excursion Module) to a safe landing site before running out of fuel. If you succeeded, a little man would walk out of the LEM over to the 2 golden arches and the screen would display “Two Cheeseburgers Please” (This was before the popularity of the Big Mac). Along the way you could see LEM carcasses of failed prior missions.

I had a lot of fun writing programs on that computer too. The program listed was written in PDP-11 Assembly language (called Macro-11). It was a terminal emulator program, which would allow the PDP-11 keyboard to be a front end for the IBM 370 TSO system (I think TSO stands for Time Sharing something). It had special escape key sequences that provided options to send files, talk to the modem, capture data to a file, etc. It was written in Macro-11: PDP-11 assembly language.

That reminds me: if you open up a command prompt (CMD.EXE) in Windows XP and do something that streams a lot of output to the window (like DIR \*.* /s) then you can hit Ctrl-S to suspend the stream so you can read it, and Ctrl-Q to continue. These keystrokes are at least 31 years old!

The print job header itself says “NOTE: THIS JOB HAS BEEN ACCOUNTED FOR LIKE ANY OTHER BATCH JOB BUT PRINTING THE CHARGE ($.25 + $0.00075*LINES) HAS BEEN OMITTED TO SAVE PAPER”

I suspect that my terminal emulator program worked because it was a PDP-11 program that was printed on the huge IBM line printer of the 370. The only way it could have been printed was if I was able to use the PDP-11 as a terminal of the 370.

Here’s a link to an image of the original document. I scanned just the first couple pages.

http://www.calvinhsia.com/slides.asp?mode=pic&fname=images/YaleTSO.jpg

57001

Floating Point calculations: comparing with zero

Calvin_Hsia — Wed, 13 Apr 2005 22:43:00 GMT

I was asked about floating point calculations. In particular, I can write code like this:

x=3.4

y=10

Result=x*y

?Result,Result=34

IF Result=34

?"This code will execute if result = 34"

ENDIF

*Output is 34.0 .T.

If you add 3 zeros to x (change x to 3.4000) then

*Output is 34.0000 .T.

Fox is keeping track internally of not only the floating point value of a number, but the number of decimal points of accuracy (I’ll call that NUMDPS). “3.4” has 1 implied decimal place of accuracy. “3.4000” has 4. When doing operations on a floating point number, the NUMDPS are tracked too. For example, when multiplying 2 floating point numbers, NUMDPS is the sum of the NUMDPS of the multiplicands. For addition, NUMDPS is the larger of the NUMDPS of the addends.

Floating point numbers are represented internally in binary. Run the BINTOC sample that ships with VFP to see the actual binary representation: Start VFP, choose Tools->Task Pane->Solution Samples->New in VFP9->BINTOC Binary Conversion

Type in 3.4 and choose “B” as the parameter to BINTOC.

It shows that 3.4 is represented internally as 33 33 33 33 33 33 08 40 hex, or 0011:0011 0011:0011 0011:0011 0011:0011 0011:0011 0011:0011 0000:1011 0100:0000 in binary

In fact, any multiple of 1/10 is an infinitely repeating fraction in binary. Just as 1/3 = .33333333333 in base 10, repeated fractions are not exact.

So what if you add 1/3 3 times?

.3333333

_______

.9999999 which is not exactly equal to 1.

So how is it that Fox says the result is equal to 34 ?

In general, to see if 2 values are equal, subtract one from the other, take the absolute value, and see if you get zero. This works fine for integers, but for real numbers, we may not get exactly zero.

We need then to determine how close to zero is close enough? Close enough means smaller than some number (often called epsilon) that is acceptable.

For acceptability we need to consider how many decimal places of accuracy are known.

If we get 34 – 33.9999999999 = 1E-10, and we only have 1 decimal digit of accuracy then we are clearly willing to accept that 1E-10 is indeed zero.

However, 34.000000000000 – 33.9999999999 = 1E-10 and we now have 10 digits of accuracy and it’s not so clear if this is close enough to zero.

Fox internally has an array of floats: 0.5E0, 0.5E-1, 0.5E-2, 0.5E-3, 0.5E-4, 0.5E-5, 0.5E-6, 0.5E-7, 0.5E-8 etc. NUMDPS is an index into this array to look up an appropriate epsilon to use.

56890

Calling the Windows APIs for Large Files

Calvin_Hsia — Fri, 18 Mar 2005 18:53:00 GMT

A customer was trying to use FoxPro to handle large files.

The files that Fox handles natively (like tables, indexes) are limited to using 32 bit addressing, (2^32 = 4 gigs). Back in the old days (not that long ago), there were no hard disks > 2 gigs. Who would ever need more?<g>

I’ve been using Virtual PC (a great product, which allows me to have many “virtual” computers exist on a single computer) and it creates files that are several gigabytes (they represent the entire hard disk of the virtual machine). I have a Win2003 Server virtual PC on my Windows XP machine and I can open multiple remote desktops to it!

Suppose I wanted to write a Fox program to read/write this large file. Not a problem: just call the 64 bit Win APIs (that were added when larger hard disks were invented).

For example, the SetFilePointer API is the 32 bit version, while SetFilePointerEx is the 64 bit version.

DWORD SetFilePointer(

  HANDLE hFile,

  LONG lDistanceToMove,

  PLONG lpDistanceToMoveHigh,

  DWORD dwMoveMethod

);

BOOL SetFilePointerEx(

  HANDLE hFile,

  LARGE_INTEGER liDistanceToMove,

  PLARGE_INTEGER lpNewFilePointer,

  DWORD dwMoveMethod

As you can see from the function signatures, the calls are almost identical: the only difference being LARGE_INTEGER in the place of LONG.

LONG is a 32 bit quantity, whereas LARGE_INTEGER is defined in Winnt.H as a Union

typedef union _LARGE_INTEGER {

struct {

DWORD LowPart;

LONG HighPart;

};

struct {

DWORD LowPart;

LONG HighPart;

} u;

LONGLONG QuadPart;

} LARGE_INTEGER;

typedef LARGE_INTEGER *PLARGE_INTEGER;

The HighPart is 32 bit signed and the LowPart is 32 bit unsigned. Put them together and you have a 64 bit signed number.

When calling functions in the Win API, the parameters must be put on the process stack, which is 32 bits wide in 32 bit Windows XP.

The SetFilePointer call thus expects 4 32 bit words on the stack, because each parameter is of size 32 bits.

However, the SetFilePointerEx function expects 5 32 bit words on the stack: the LARGE_INTEGER is 2 32 bit words.

You may be thinking: what about the PLARGE_INTEGER ? isn’t that 2 32 bit words too? Actually not: it’s not a LARGE_INTEGER, but the address of a LARGE_INTEGER. Addresses in 32 bit Windows are 32 bits (surprise!).

So, how do we call such a function in Fox? We just pass 5 32 bit words on the stack by Declaring the LowPart and HighPart separately: See code below. Notice that the SetFilePointerEx Declare statement shows 5 parameters. Fox just puts those parameters on the stack and the Win API call proceeds merrily along.

The sample code just opens a file and does a SEEK to a 64 bit offset into the file and shows the resulting position pointer.

(thanks to Jim Saunders for the problem and sample code).

#DEFINE CREATE_NEW 1

#DEFINE CREATE_ALWAYS 2

#DEFINE OPEN_EXISTING 3

#DEFINE FILE_ATTRIBUTE_NORMAL 128

#DEFINE GENERIC_READ 2147483648 && 0x80000000

#DEFINE GENERIC_WRITE 1073741824 && 0x40000000

#DEFINE GENERIC_ALL 268435456 && 0x10000000

#DEFINE MAXIMUM_ALLOWED 33554432 && 0x02000000

#DEFINE STANDARD_RIGHTS_ALL 2031616 && 0x001F0000

#DEFINE FILE_SHARE_READ 1

#DEFINE FILE_SHARE_WRITE 2

#DEFINE FILE_SHARE_DELETE 4

#DEFINE INVALID_HANDLE_VALUE -1

#DEFINE FILE_BEGIN 0

#DEFINE FILE_CURRENT 1

#DEFINE FILE_END 2

#DEFINE MAXDWORD 4294967295

CLEAR

DECLARE INTEGER CreateFile IN kernel32 STRING lpFileName,;

INTEGER dwDesiredAccess, INTEGER dwShareMode,;

INTEGER lpSecurityAttr, INTEGER dwCreationDisp,;

INTEGER dwFlagsAndAttrs, INTEGER hTemplateFile

DECLARE INTEGER CloseHandle IN kernel32 INTEGER hObject

DECLARE long GetLastError in win32api

DECLARE long SetFilePointerEx IN kernel32;

long hnd,;

long lDistanceToMoveL,;

long lDistanceToMoveH,;

string @lpNewFilePointer,;

long dwMoveMethod

filename = "E:\VirtualPCs\MyVirtualPCHardDisk.VHD"

fh = CreateFile(filename, ;

GENERIC_READ,;

FILE_SHARE_READ,;

0,;

OPEN_EXISTING,;

FILE_ATTRIBUTE_NORMAL,;

IF fh = INVALID_HANDLE_VALUE

= MESSAGEBOX("Could not open "+filename,16,"")

return

ENDIF

cNewFilePointer = REPLICATE(CHR(0),8)

lDistanceToMove = 2^32+5

*lDistanceToMove = 2000

?"Dist=",lDistanceToMove

cpH=INT(lDistanceToMove/2^32)

cpL=lDistanceToMove - cpH * 2^32

?"High,Low=",cph,cpl

nret= SetFilePointerEx(fh, cpL,cpH, @cNewFilePointer, FILE_BEGIN)

*nret= SetFilePointerEx(fh, cpL,cpH, @cNewFilePointer, FILE_END)

IF nRet = 0

?"Error",GetLastError()

ENDIF

newfp=CToLI(cNewFilePointer)

?"Newfp=", newfp,LOG10(newfp)

=closehandle(fh)

CLEAR DLLS

RETURN

PROCEDURE CToLI(str as String) as Number && str is an 8 byte string

LOCAL num,i

num=0

FOR i = 0 TO 7

* ?i,ASC(SUBSTR(str,i+1)),TRANSFORM(ASC(SUBSTR(str,i+1)),"@0x")

num = num + 256^i * ASC(SUBSTR(str,i+1))

ENDFOR

RETURN num

54461