12/31/00 V0.01
I have made the main core of the intel assembler, (or, remade) this time,
it's in assembly. The loading of the lines (getline) is slow, because it
loads one line at a time rather then a larger chunk, and then verifying.
I will update this some time after i fix it all.. I may be able to delete
a whole section (64K) But, does it really matter?
I also have started on the instruction identifaction algorythmn, to make it
smaller, as well as faster, and easier to update, i am making it a library
format. I will explain how it works some time later. I suggest not to touch
it yet (incomplete)
Primary functions include:
1) Loading Assembly file, and filtering out empty lines and comments.
2) Uppercase everything (except for within the "'s)
3) Identify and use labels (also prepairing, based also on CPX)
Coming functions:
1) Identifying the Instructions (with extensive information)
2) adding more label support (+, -)
3) Adding more number support (getnum will add and subtract as well)
4) Includes (allowing the Includes, also, a special Instruction, INCLUDE)
(INCLUDE will tell it where to paste all the include data, so the rest of
the data (at the end, labels?) Are un-effected)
5) update every CPX on every label ($)
6) Identify and use $
List of Reserved Label names, and information:
DB - Direct Byte, Straight input (built in) (text allowed)
DW - Direct Word, Straight input
DQ - Direct Quad, Straight input
DDW- Direct Double Word (same as quad)
- Location to paste includes.
:
A special set, you can put in a number (computer version, 386 ect)
16 BIT - Native 16 bit instructions
32 BIT - Native 32 bit instructions
This tells it how many loops it must preform before the final phase.
(minimum of 1)
Saves a text for the FASTFILE (for comparing, so you don't make faulty
software, should the text fail to match, it will display an error, and skip
the fast file, resuming normally (a little slower, but will work))
1/10/01 v.02
Working on the instruction identifyer, this is no easy task. I have also
come up with an idea for software compadibility, and extending the sets,
slightly.. This will save SOME programming time, and a few lines of code,
Technically, they are Macro's, but as long as they are within 16 bytes, and
saves everyone from having to write too much to do the same thing, i am
happy with it. Best part, is they don't take up that much more space, so you
can write software for 386+, and then compile it for 8086+, and it will
still run. (i don't think there are THAT many people that use it that much)
Also, a slight 'Extended' Set, is allowing segment/segment manipulations, and
a few other tasks. But these will get big after a while, unless i come up
with a new method to encode it, which makes my work VERY slow.
Anyway, i have the single instructions completed, for now i will finnish
the main core, after i touch up the code.
1/26/01 v.03
Some updates..
I have added complete Addition and subtraction with labels. You can now do
that to all labels, instead of CPX. Also, i put a little shortcut in, and
when you work with CPX, it will recodnize it, and update it accordingly. So
that's working. (+ -)
I found a bug in my Instruction Identifyer, and i have fixed it. Right now
it only does the single instructions, without any input data, but that will
fix soon enough. I will have a beta out soon enough.
I've also added Debug printing.. I haven't quite got it finnished, but a few
more minor changes, and the core is complete.
What i need to add in:
Addition and subtraction in the number identifyer. This will allow a lot of
flexibility. Once i get it working anyway.
And updated Getline, to get 1 line, but this way MUCH faster, it will take
some time.
Instruction Identifyer:
1 and 2 data in's to complete the list.
Identifying jumps, and other bits
Section Identifyer completing (bugged)
The program is on the way :)
2/3/01 v.04
I have added in the new GETLINE command, built to be faster, and more
effective. Only a touchup required for it to be ready.
Also, in the hew GETLINE, it supports UNICODE loading.. from UNICODE, and
ASCII. This allows for a stable, useful, translator. (before using GETLINE,
use GETLINE_CLEAR which will prepair a 64K block for use with getline. Each
64K block will work with 1 file(Buffer?))
I have added the special controls in, and i have a beta of the program
working. Adding in are various tools, but i have overruled a new set for
jumps. Instead i have devised a smaller, more complete routine, that will
work for the time being. in fact, it should work reguardless..
A few bugs, in the PART identifyer (identifies the first and second data
parts) and it works now.. will identify 0,1 and 2 parts. (3 parts are special,
i might build one, should i understand HOW it works..)
NOTE: INCLUDE, This special instruciton will include the INCLUDE information.
(special run) Also, ALL information directly involving 'Structures' will start
to be supported. I will supply rules for the structures and includes.
2/5/01 v.05
More work on the instruction Identifyer, and also. I have rebuilt the entire
GETLINE command. This new command, is just bigger. It also works a whole 64K
section for a file buffer.. This way, in basic terms.. Is faster, because
it doesn't keep requesting just 1 bytes.. instead, finds the line, and
copies it.. All of it isn't there? oh well...
To make it easier, i have changed the instruction set part in for the set
you wish to use.. You add a period in now. (like Microsoft's one.. so it's
compadible, and you get the feel of it..)
3/5/01 V.06
Fixed a bug, and i have the main of the instructions with 1 input in working
but needs work. The bug was not printing the whole line of it's current
information, as well as finding a bug in my V.23 compiler. (can't fix yet)
I also have the whole instructions (text only) working. I can do basic
programming for tests now, but they don't need a lot of work. so the SET is
done for now, supporinting about 60 instructions (single, MMX, FPU?, and
others)
5/18/01 V.07
Working in on some of the instruction set, while adding in parts for Register
access. The Identifying parts are done, as well as the registers in, for the
set file. I have tested, and it works well. There seems to be 2 bugs present
that make a large difference. First, is if you leave a label empty (without
and instruction immedately following) the last instruction will repeat.
The second bug, has to do with the Call (jumps?). But a bit more is done.
The special instructions of DB has to be entered in manually for it's own
section (being built in) as well as specials need to be finnished.
5/19/01 V.08
Completed, Several bugs have come forth, in a beta test, and i have found
and removed the most of them. Including a number bug, where it was searching
for the wrong thing. And also, the num_type check, if you have WORD or BYTE
in, it will have that overwritten.. now if it's unused, it will add it. All
number computatiions (if not locked) will be flexible now, based on the number
before it creates the code. Also, several instructions were added.
5/21/01 V.09
Fixed the last of the original bugs, and the 'Exact' formula is working.
Other parts are being put in and tested as of yet. The empty label is now
fixed. Negatives are fixed, and negative identifacation, is working
(and updated), for now. Registers are up and running, with their exacts.
What's left is the memory (the hardest part). Afterwards, all single input
instructions will be added in.
5/21/01 V.10
Some more bugs found. Based on the instruction set and database. Several new
checkers are in place, and will notify when the database holds bad codes. The
original 'standalone' instructions had a couple bugs, and needed a major fix.
The 'Opinclude' is now limited to the first 3 for those (rarely used) but
otherwise works fine. As well as an update to the code for it, where it no
longer just adjusts it if it's 32 bit, but also for 16 bit (same as single
and dual inputs).
Most of the Single instructions (1 input) have been added, but they lack the
power of memory access (yet) which will be done soon. Backups of special
'exact' instructions have been made, until it's complete. And the general
ones are left on (also alternate encodings), which will work until it's all
complete. In the set file, i had to change a bunch, and fix my own errors.
I have also added in a special encoding for the single instructions (1 input)
When it's doing a register, the space that was reserved for numbers only, was
opened up, allowing lots of flexible programming. Rather then having to add
tons of exacts, it will free up the special encodings for the single
instructions. When complete, i will take on the challenge of the duals.
5/22/01 V.11
Another bug found. This bug simply, was wrong. Every time the database was
searched, the new instruction (reguardless if it was used) was saved as the
new information. Should it be skipped through (unknown instruction) it might
write a 32bit change.. Now it will not save it until it's properly written in.
5/25/01 V.12
Getnum has new codes in it to understand the end of the number. And adding
power to the DB, DW and DQ/DD commands, for internal instructions. So far
they understand, and computate numbers. Also input's Text, but requires the
DUP half of the instruction, in the following format:
DUP(datasize), number/text
Ex. DB DUP(255),45
OR Ex. DB DUP(255),"TEST" (will loop TEST until 255 characters are met)
But some updates still need to be done.
5/26/01 V.13
But in REPLACE found. Two parts, if the value was 0, it was emptied, but
never replaced. Now works with 0's. Also, it only looked for the first one.
Now will find all matches and replace them.
5/27/01 V.14
More bugs, Involved in the identify. There's a bug with an empty line
(just after using a label) i am going to fix it, since i haven't yet. As well
as some slight re-arangements will remove all error codes from getting involed
until they are ready. The direct code seems to work Flawlessly, and will
not be changed for now.
7/09/01 V.15
Work on the memory is slow and tedious (as my assembler is slow right now)
but it's getting there. I have just completed the majority of the work, now
to add in the codes, and get it going. Memory_part Done.
7/14/01 V.15
Memory functions are done, i've also fixed a distance32 bug, having set in
the wrong values. Now they will read right. In a couple days, all single
instructions will be entered.
7/16/01 V.16
Well, in the process of testing it, i ran it through it's own source code.
I ran into a problem, it died. When i looked in the temp file, a single line
was being re-written over and over and over again.. never ending.. I spend
plenty of time, when i looked at the next line, it was all spaces. That was
the bug, and now it's sifted out, looking for that before trying to use the
line as code. (annoying little devil). Anyway, the assembler is VERY fast :)
12/24/01 V.17
Programming away. I am putting in the EXACTS for the two inputs, and
finnishing my incomplete work. Oh, all single instructions, and single in,
instructions are in. Time for this part to finnish the rest.
12/25/01 V.18
Annoying bug found, In a previously 'done' section (1 input) i found a
Nasty little bug, when executed for a memory location, and then the memory
size wasn't right, it skipped the next instruction in listing.. that could
easily MISS the next one in line.. Which is what it did. Though i would
bring him up, he's a special one :) the bug is from when the ADD SI,4. When
then later, executed the instruction 'jmp near nomatch4' which adds 3, it
gets lost and skips the instruction. Bad way to go. Now it's fixed.
12/27/01 V.19
More tidbits fixed. Also Started writing in the codes for the rest of the
2 input instructions. We will see how it comes out.
12/29/01 V.19
Things to ADD:
Local Loops: ".label" These are the same as labels, only you can have more
then one of them. The closest one to CPX will be the one used.
(in the code, will have locations (32bit) for all labels of
the name of the local loop)
Macros: Preset assembly sets. Either in DB form, or in actual code.
That is up to the user. (probably code) notes allowed too.
Object code: I am not sure, depends on how the hooks work.
Workaround: ENTER (2 immediates), and for 2 regs, that are backwards.
(the uncertain code (2 bits) may determine that information)
Variables: Variables, common in other systems without the label Colon :
Setless: Clear the SET segment before starting. (Without the set, stable)
Signed mem: Signed Memory (with immediates) need help. Probably the uncertain
2 bytes will help here.
01/01/02 V0.20
Workaround complete, along with a few other settings. Found another bug,
this bug has to do with the SETS file. if a SET file isn't there, the
program closes a wrong port, and tries to read from a bad port too. should
be fixed now.
01/02/02 V0.21
Found the segment codes were wrong, they are fixed now. There's some bug
with larger files, that memory functions (with immediates) don't work right,
working at it now.
01/04/02 V0.23
Fixing little details and bugs that needed to be fixed. Fixed a bug allowing
two exact registers should work right now. (or better anyways)
01/05/02 V0.26
Fixed and added in for Jumps, if they aren't set, it tests them, and sets
then either SHORT, or NEAR. But it won't show in the code. (Nasty bugs there)
Anyways, got new versions of that going, other bugs gone, it works, and
other programs work too, with minor adjustments. V0.27 will be selfcomplete,
not needing a SET file, but the set file will have to be included in it.
(Reminds me of other features to add)
Features added already: Setless, Signed Mem, 'undefined' jumps / calls,
fixed ENTER bug, and backwards codes.
01/05/02 V0.27
Self sufficiant program, ready to run :) set files for special cases, if no
set file, it runs it's own :)
01/05/02 V0.29
Added and finnished the FASTFILE Make, and FASTFILE read. Makes those
projects easier. Also got some emulated instructions in the IDTEST.
01/06/02 V0.30
With a small experiment, saw that there was a problem in the 'undefined'
jumps, a chance that it could not work.. that's fixed now. And reconfigured
the Self Sufficiant part.
01/06/02 V0.33
! * # includes are in and working.
*Filename: Immediate input, total from file. In this spot
#Filename: Functions to get from
!Function: Functions to get
01/07/02 V0.35
Optimazation added. This coding will ignore the codes set forth by means of
SHORT and NEAR.. and choose the best of them, and of the instructions. For
Simple programming, make all jumps and calls NEAR, and then use this to
shrink when space is needed, or when you are done the final product.
Also fixed a bug, and added more error codes in, in case functions aren't
put in right.
01/07/02 V0.36
Fixed minor bug, and added a feature, that may never be used. But it's there.
01/07/02 V0.37
Put Workaround for 3 inputs, the third being a number. (MMX)
01/08/02 V0.38
Fixed a few bugs, And added a few override, allowing certain MMX features to
come along. Also allowing the FPU to work easier. And found bugs there to.
That was hard work :)
01/08.02 V0.40
Few bugs fixed, and the Distance for FPU functions are finnally working.
Extended options, so when you use 64bit, it changes the number function, so
it's X4 of what you put in. so here's the chart.
Bytes Bits
Input: 0 1 2 3 0 1 2 3
Not64: 0 1 2 4 0 8 16 32
Now64: 0 4 8 16 0 32 64 128
01/08/02 V0.41
Added 64bit support to Single instructions, for FPU's.
01/09/02 V0.42
Fixed small bug, for smaller files using the Optimize, it ensures that there
are a minimum of loops for the fixes.
01/10/02 V0.43
Found a strange bug with the DUP() command. the bug wasn't obvious, unless
it tried to write at FFFD or higher, because that overrides the size, making
a segment overrun. (Major error) It now checks to see if it will do that,
and if so, will put them in place. they should fix themselfs, usually 0's
or negs, and will do fine :)
01/14/02 V0.44
Well, i noticed a bug, that negs weren't fixed. I fixed it with a slight
change. If it's a neg, it will make 1 of the smallest size. (minimum) and
if it's larger then it should be? Well, it makes it at the max. simple as
that.
01/14/02 V0.45
Removed annoy spaces from the : to the instruction in the 'debug' file, and
output.
01/14/02 V0.46
Removed the spaces in the 'debug' file, from labels ends. took a little work
01/16/02 V0.47
Finnished Specials (for now) Allowing Switching between 32 bit, 16 bit, and
different computer versions. Here they are now. (These will be fine, until
more are needed.)
Computer Version Ex: <.286>
Originate location Ex:
16 Bit Processing Ex: <16 BITS>
32 Bit Processing Ex: <32 BITS>
01/03/02 V0.48
Fixed a bug with the segment overrides.. it would mix up labels, if they
ended with the segment similar. Example: test_cs: this makes the error.
it should be fixed now.
01/03/02 V0.49
Added QUICK feature. This is for when you want a program quicker out, and
will assume ALL jumps to be at least a near.
MAJOR NOTE: When doing a FAST make or FAST use. Always assume it's going to
use Optimized. Otherwise there could be bugs. (Or unless otherwise specified)
02/09/02 V0.50
Workarounds have been added for: ENTER. (which needed 2 numbers) the data
for now is perminently set for the first half to be a word. Second part is
the size for determined input. This allow enabled the 'exact memory' that i
delayed on working on. That is now in, and working.
02/18/02 V0.51
Added check support for the TEST.SET file. Main concern is with
compadibility with the version. Some newer versions of the TEST.SET won't
work with older versions of the program, as other workarounds and features
are added. So the version will take effect, for what version is needed (at
least) for it to work.
Also a note. FAR jumps have NOT beed added as of yet. When they are needed
I will add them.
04/11/02 V0.52
Seems somewhere along the way i deleted my specials. Had to re-add them,
so here they are again. NOTE, this time around i've added another. SET
for the optional includes. Should be most interesting :)
04/21/02 V0.53
Added the 'offset' for compadibility to the list. Although it does nothing
as far as i can understand. I've also added some more IMUL functions that
i didn't know about, and fixed a bunch of FPU functions, even though i don't
know how they work.
Also fixed a BUNCH of codes in for the FPU single inputs, and added a few
more instructions.. Trying to make Workaround for 3 inputs REG,REG,CL. And
there's a new override which makes certain instructions complete and
a bit more proper.
Also, Added Unicode Support. Instructions from the GETLINE were incomplete,
but now it is complete. It can take inputs from UNICODE, BUT make sure all
inputs are unicode as well. (includes, extra functions Ect) otherwise they
will be treated like unicode.
To make it easier, i've added the Auto Unicode. This checks every line for
unicode. Will work on all files and compadibilities.
04/23/02 V0.54
Floating point has been added to the program. Here's an update on some
things. (manuals usually say DEFINE, but i say DIRECT :P)
DB - Direct Byte (1) Integer
DW - Direct Word (2) Integer
DQ - Direct Quad/Double Word (4) Float 8:24
DD - Direct Quad/Double Word (4) Float 8:24
DO - Direct Octal (8) Double 11:53
DT - Direct Tbyte (10) Tbyte 16:64
I've fixed a small bug involving the numbers, the spaces should not give us
any more problems.
The Floating points will fit themselfs into the size of the Defined/Direct
input. But all calculations are done in the largest possible, until they have
to be sized down. And, Rounding up is on, if you need something else, you
will have to re-compile the program. But remember, when you use FPU anywhere
else EXCEPT the Direct/Defined areas, it will automatically be reverted to
an Integer.
Also for calculations, i have added the following ability in numbers which
is called 'I'. This tiny function overrides the floating point, and
re-assumes the number to be a Integer. It's merely an Inturrupt. Example:
DD 10.1 * 5.3 ;this will be saved as the float 53.53
DD 10.1 * 5.3I ;Now it will be saved as a normal 53
DD 10.1 * 5.3I+24 ;77 :P
Merely having the period in the number will turn the whole calculation into
a floating point. Only by using I will it revert. Should the system lack a
FPU, the floating half is ignored, leaving it whole numbers.
Another note, i have added the OFFSET into the code, which is then just
deleted. this way you don't have to change as much code to use it in the
assembler.
04/23/02 V0.55
I've decided to make it easy on everyone, and put in the controls for ()'s.
So, you can now do calculations on the basis of ((5*5)/2)/5.0 and stuff
like that if you so choose. One little bit of information on it first.
Like the other compilers, you need to put in <.387> to get it to work.
AND, all levels are assumed to start at integer level. Example.
I=Integer F=Float
(I (I (I (I (I (I) I) I) I) I) I)
This allows for some intereting coding. Want one level or two levels as
Floats? easy, just define it with the numbers (One of the numbers must
contain a period for the fraction/float).
On three levels, it would work like this
10+((3.5*11)/6.0) I10+((F3.5*F11)/F6.0)I, simply, when it returns, it
returns the previous format with it. (Float or Integer)
There's also error checking, so just be looking ok?
Error8 has been turned off, but can be turned on by Recompiling the code.
Since it's a optimizing hint, rather than an error, but most of the time
is ignored. For now it is ignored.
04/26/02 V0.56
Fixed a bug, ( will assume to be a number from now on. (Math calculations)
Also, Macros are being added, the format is as follows.
%%MacroName %1,%2,%3 ;must start with % and number, and also,
;instructions here ;commas are required
mov bp,%1
mov %1,%2
Macroname%M: xlat ;%M is a counter, when that is found, it will replace
mov [bp],al ;that with a number of the count
inc bp ;This will use the 'Unicode' translate, so
mov al,[bp] ;be ready for something silly looking
loop Macroname%M
%%em ;Em is simply END MACRO. (Adapted from A86 compiler)
So the important summery is these.
%%Macro ;define macro
%M ;counter
%n ;n is a number, for what placement it has in the macro
;can be anything (Even a text), within the db limits.
;1-9 limit
%%EM ;End Macro
There is also a jump bug in the program somewhere. This bug is only there
when you compile it regularly. Probably because it doesn't have enough runs
to get it properly fixed. To resolve this, make it QUICK or OPTIMIZED.
04/28/02 V0.57
Fixed major bugs in the Macro functions, should work better now.
04/29/02 V0.58
Added codes for FAR jumps. Added a beta text, when you enable it. For Far
jumps as follows.
JMP FAR 0000:0000h ;correct 16 bit
JMP FAR 0000:00000000h ;correct 32 bit
JMP FAR 0000h:0000h ;INCORRECT 16 bit
JMP FAR 0000h:00000000h ;INCORRECT 32 bit
don't bother with understanding much of it, they are numbers, and the
Segment (first part) will automatically follow the same format as the IP
half. If you do try to override it, the number will be incorrect. I
can't easily fix this, so i won't, sides it looks fine the way it is.
04/29/02 V0.59
I've noticed a bug in the floating point. When you do a floating point,
ALWAYS start it with a number, even if that number is 0. IF you don't,
the program won't recodnize it properly, and could harm your system.
I've added a failsafe for this, but that will help you with your coding.
04/30/02 V0.60
Extreame difficulty adding FAR to some commands, including JMP and CALL.
But they should all be working now. Also, you can do QUAD jumps (32 bit
jmps, like a near) but the computer will automatically identify it as
before. But you can now put an override for the data input as well, don't
abuse it.
JMP NEAR 100h ;regular near nump
JMP QUAD 100h ;32bit near jump
Also a little but noticed, when it switches for 32bit code, it's off by
one. It's a prefix addon, that wasn't figured. Now it's fixed.
05/01/02 V0.61
Added in compadible functions from other assemblers. The following has
been added.
somedata db 0,0,0 ;defined BYTES
somewhere2 dw 0,0,0 ;defined words
somewhere3 dq 0,0,0 ;defined Quads/Dwords Ect Ect.
In the defined bytes, they now are predefined, if you don't override
them. This means, you don't have to define areas of memory you have
used these on. Example.
inc word [bx+memarea] ;before
memarea: dw 1,2,3
inc [bx+memarea] ;now
memarea dw 1,2,3
The rule on this, is that two functions are taken in place when a memory
is used. If not, the location (memarea) just a number. If it is, it will
transfer the overridden Segment, as well as the TYPE it had. (Byte, Word
Quad Ect). (Segments are not enabled at this time, but have been tested)
To make this work, the structure for the FASTFILE has been changed, and
therefore won't work on the earlier versions anymore. Here's the two
structures to look over.
OLD:
Textsize (1 byte)
datasize (1 byte)
Datearea (Datasize)
NEW:
Textsize (1 byte)
datasize (1 byte)
Extended (1 byte)
Dataarea (Datasize)
The extended is as follows. (downwards like in the idtest.asm)
FAR (1) (Calls, NEAR is auto, FAR is for this.)
Segment (3) (Segment override)
Datasize (4) (Multiples of 2) (0,1,2,4,8,16,32,64,128,256 Ect)
0 000 0000
FAR SEG DATA
Structures will come in at another time.
As will Procedures.
Formatting to work with (once they are in)
PROC name SEG ; Far if it takes a far jump to get to. Seg is what
;segment function you want to use with it (CS,DS,ES,FS,GS,SS)
ENDP name ;once the ENDS is on, it just gives up on it all :P
STRUC name ;Structure name
ENDS name ;ends structure
05/02/02 V0.62
Updated for the procs to work right, New rules have been added for
programming. VERY important.
In every part of the program as it picks up labels, locations, data, Ect
it gives it code number to follow, counting the procedure it's in. The
main (starting one) is 1, the next one is 2, Ect. Up to 65536. (more then
enough for now)
Anything with a value of 0, will be accessible by all the program.
Locations for the most part are the peices that need to require the number
to be identicle. Anything with a prefix (Data set/change) will be set
with the value 0. ALSO, any defined data in the new types will be set to
0 as well.
And one more, The label location for the calls for the procedures will be
valued 0 as well. For internal structure, this is important, anything else
doesn't matter.
So. Here's a quick overview.
^blah1 5 ;value 5, accessible by whole program
%blah2 100 ;vale 100, accessible by whole program
proc blah3 ;location, accessible by whole program
blah4: ;location, accessible only in blah3
endp ;end of procedure
blah5 db 0,0,0 ;location & type identify, accessible by whole program.
05/03/02 V0.63
Found some interesting bugs, and fixed them, involving the Direct input DUP
the LabAdd (Adding labels) and a few other gizmos. Also a note, for Version
V0.56, you may want to compile it with the previous GETLINE CX lines, and
then do the new lines after that, just a little thing i happened to notice.
Other bugs involving the PROC have been taken care of, tell me of the bugs.
05/04/02 V0.64
Found some bugs present in the 32bit coding for the memory, and for numbers.
I had known there were a few bugs in that area, but after looking more in
depth, i found one code to be a simple mistake, and another i just added
a few lines in, and changed a little code. Both should be working properly
now.
05/08/02 V0.65
Strange bug, i had to work with IDTEST a lot to get far calls so i could
do some work with the XMS drivers. But then they screwed up all the calls,
so here's the fix for them. All calls should work properly now.
(
geocities.com/siliconvalley/haven) (
geocities.com/siliconvalley)