Print Page - SBJS

Information => Open Forum => Topic started by: JRS on September 12, 2016, 09:12:35 AM

Title: SBJS
Post by: JRS on September 12, 2016, 09:12:35 AM

Thanks Charles!

That solves the position in the bit map and unmystifies the ORing of these flags. Setting them to TRUE/FALSE still has me scratching my head. I'm on the fence to try to wrap this as a C function or emulate it in Script BASIC.

I think its checking v (object pointer) to see if it exists (non-NULL) before setting a TRUE/FALSE condition.

HERE (https://github.com/cesanta/v7) is the Github project site for V7 if needed.

My plan is to create a Windows JS extension module once the Linux version is done.

I think V7 would be a cool extension to O2 as a DLL interface.

HERE (http://www.allbasic.info/forum/index.php?topic=450.0) is a thread on All BASIC about my progress embedding V7 in Script BASIC.

Title: Re: SBJS
Post by: Mike Lobanovsky on September 12, 2016, 02:46:55 PM

Quote from: Charles Pegge on September 12, 2016, 02:55:19 AM

if v then return n or (n<<16) else return n<<16)
---->
if v then return n*0x10000 + n else return n*0x10000

Mmm, I'm afraid not exactly.

While <<16 and *0x10000 are interchangeable and we may even drop the (v7_prop_attr_desc_t) member of the macro painlessly because it's effectively just a cast of n to an unsigned long (cf. typedef unsigned long v7_prop_attr_desc_t;) to shut up the C compiler's strict type checking, we may not substitute bitwise or with addition here.

So, both

If v Then Return (n BitwiseOr (n << 16)) Else Return (n << 16)

and

If v Then Return (n BitwiseOr (n * 0x10000)) Else Return (n * 0x10000)

are safe for any given n and their combinations be they signed or unsigned, original or cast, as long as we're shifting to the left. When shifting to the right, we must also be aware of signed or unsigned n shifts. In the case of signed negative n, C will preserve its highest-order bit (the leftmost one in Calculator's binary number representation, or the 31st one in the 0..31 bit range) in its place while right shifting. OTOH the highest-order bit of an unsigned n will be right-shifted down together with the other bits in this number. So, right shifts, if any, is where the (v7_prop_attr_desc_t) cast would also matter.

But at any rate, for such a dramatic headlong dash to the left addition is only usable up to a certain "pivot point" where the total of bits in n wouldn't exceed 0xFFFF0000, because any attempt to add yet another bit (i.e. property attribute) to the total rather than bitwise or them together would yield an entirely wrong total:

Code: C

#AppType Console
 
? "test 0xFFFF0000"
test(0xffff0000)
? "-------------------------"
? "test 0xFFFF0001"
test(0xffff0001)
 
DynC test(%n)
  void main(int n)
  {
    printf("    signed + : %d\n", n + (n << 16));
    printf("  unsigned + : %u\n", n + (n << 16));
    printf("(unsigned) + : %u\n", (unsigned)n + ((unsigned)n << 16));
    printf("    signed | : %d\n", n | (n << 16));
    printf("  unsigned | : %u\n", n | (n << 16));
    printf("(unsigned) | : %u\n", (unsigned)n | ((unsigned)n << 16));
  }
End DynC
 
Pause

Output:

test 0xFFFF0000
signed + : -65536
unsigned + : 4294901760
(unsigned) + : 4294901760
signed | : -65536
unsigned | : 4294901760
(unsigned) | : 4294901760
-------------------------
test 0xFFFF0001
signed + : 1 <== All wrong! 1 means V7_PROPERTY_NON_WRITABLE!
unsigned + : 1 <== ditto
(unsigned) + : 1 <== ditto
signed | : -65535
unsigned | : 4294901761
(unsigned) | : 4294901761

Title: Re: SBJS
Post by: JRS on September 12, 2016, 08:40:45 PM

Mike,

Should I try to keep this bit shift stuff in C and just pass property attribute status info to an extension module routine? (if possible)

Title: Re: SBJS
Post by: Mike Lobanovsky on September 12, 2016, 10:08:17 PM

Exactly!

You won't be able to express the entire range of this macro's conditions in traditional BASIC without a lot of time-consuming extra compensatorial math.

If you can, prefer to leave it on the C language side of the SB:C interface.

Title: Re: SBJS
Post by: JRS on September 12, 2016, 10:19:35 PM

Thanks Mike!

I'll take your advice. The unknown (for me) is can I assign a parameter in a macro as a variable passed from a SB ext. module function call?

Title: Re: SBJS
Post by: Mike Lobanovsky on September 12, 2016, 10:37:30 PM

The macro would accept valid literal or variable v and n arguments: v should evaluate to a whole integer (0 = FALSE, otherwise TRUE), and n can be any literal or variable. The C side of the interface should explicitly cast any v that comes in from the SB side to an int, long, or BOOL, while the macro's (v7_prop_attr_desc_t) cast (i.e. (insigned long) cast) will be applied to any incoming literal or variable n automatically.

Title: Re: SBJS
Post by: JRS on September 12, 2016, 11:52:55 PM

Excellent!

I'll give it a shot and see what happens. I will make a seperate ext. module call for each property attribute option. All I should have to pass is v (object pointer) and a true/false for the attribute state. I should be able to OR the property attribute functions results (using Charles's bit mask table values) in the SB function v7_def() call.

Code: C

v7_def(v7, v, "foo", -1, (V7_PROPERTY_NON_WRITABLE | V7_OVERRIDE_ATTRIBUTES),v7_mk_number(v7, 1.0)),0);
 

Code: Script BASIC

rtncode = JS::DEF(jsobj, propobj, JS::V7_PROPERTY_NON_WRITABLE(1) OR JS::V7_OVERRIDE_ATTRIBUTES(0), JS::MK_NUMBER(jsobj,1.0)),0)
 

Title: Re: SBJS
Post by: Charles Pegge on September 13, 2016, 01:30:35 AM

Hi Mike,

Yes, Script Basic only uses signed integers as its integer type, so one would need to ensure that only bits 0..14 were used to encode all the attributes, before using multiplication and addition.

The header section posted by John shows only bits 0..8 being used.

But I find the scheme of this header perplexing.

Title: Re: SBJS
Post by: JRS on September 13, 2016, 01:49:51 AM

Quote

But I find the scheme of this header perplexing.

Q. How many function variations can you fit in a one line macro?

First there is defining each property attribute with a shifted ORable bit driven sequence followed by property existence validation and finally attribute state assignment. (true/false)

Title: Re: SBJS
Post by: Charles Pegge on September 13, 2016, 03:00:03 AM

Perplexed because I would expect bit attributes to be handled in a simple manner:

Testing attribute n in v
if (v and n) ...

Setting attribute n in v
v or=n

Clearing attribute n in v
v and= not(n)

Inverting (toggling) attribute n in v
v xor= n

Title: Re: SBJS
Post by: Mike Lobanovsky on September 13, 2016, 06:34:26 AM

@Charles:

Quote from: Charles Pegge on September 13, 2016, 01:30:35 AM

... so one would need to ensure that only bits 0..14 were used to encode all the attributes ...

Hi,

That's exactly what I meant by extra BASIC arith.

Quote from: Charles Pegge on September 13, 2016, 01:30:35 AM

The header section posted by John shows only bits 0..8 being used.

That's correct but the end user's visual memory may render them an ill service elsewhere the next time they try to add high-order bit flags instead of bitwise or them. After all, John's extension module aims for BASIC, not C, end users. :)

Quote from: Charles Pegge on September 13, 2016, 01:30:35 AM

But I find the scheme of this header perplexing.

I think that's clearly not a valid C header file but rather a mixture of snippets:

#define _V7_MK_DESC(v, n) \
(((v7_prop_attr_desc_t)(n)) << _V7_DESC_SHIFT | ((v) ? (n) : 0))

may not precede

typedef unsigned long v7_prop_attr_desc_t;

because the C preprocessor knows nothing of such an O2 goodie as #lookahead. :D

@John:

Hi,

I seem to fail trying to find Peter's original site with full SB documentation to read up on SB's bitwise logic and stuff, and your All Basic link to the SB Reference (http://files.allbasic.info/ScriptBasic/commands.html) seems incomplete.

Quote from: Charles Pegge on September 13, 2016, 03:00:03 AM

Perplexed because I would expect bit attributes to be handled in a simple manner:

So am I. I wouldn't expect v being anything else but n itself, tested for n != 0...

Quote from: John on September 13, 2016, 01:49:51 AM

Q. How many function variations can you fit in a one line macro?

Actually, a hell of a bloody lot. :D

The C preprocessor is a language unto itself all right, a valuable extra shipped free out of the C box. Its "glue" operator ## would allow you to work miracles chopping your C code and gluing parts of it (down to separate letters' level) at will according to your very personal idea of what "readable code" means.

I've seen pieces of code rendered absolutely unmaintainable due to the author's very peculiar notion of "code readability".

But I've also seen compilable PP code that would express in a handful of lines almost the entire functionality of a library compatible with licensed zlib.dll. ;)

Title: Re: SBJS
Post by: JRS on September 13, 2016, 09:24:31 AM

HERE (http://www.scriptbasic.org/wiki/index.php?title=Main_Page) is a link to the Script BASIC wiki. It contains the user and developer guides along with docs for some of the extension modules.

Peter Verhas's (original author of Script BASIC) www.scriptbasic.com site is no longer. He is Java centric and I don't see Peter going back to C anytime soon.

Quote

The C preprocessor is a language unto itself all right,

I think C BASIC is a good example of that.

Title: Re: SBJS
Post by: Mike Lobanovsky on September 13, 2016, 03:26:25 PM

Oh, thanks John!

Developers Guide - ONLINE is exactly what I've been looking for.

(sorry for confusing Peter with Paul -- my sacrilegeous blunder's just been fixed) ;D

Title: Re: SBJS
Post by: JRS on September 13, 2016, 04:26:51 PM

Mike,

I think I have everything figured out except the OR aspect of these property attributes. I was thinking of the SB ext. module attribute functions returning the shift offset value Charles posted. Do you see that as a valid solution?

Update:

I think I'm going to use the following method for setting/clearing property attributes. If the attribute flag isn't passed it is (re)set to zero (false) unless P is passed which leaves unreferenced attributes as is.

Code: Script BASIC

JS::DEF(jsobj, propobj, "my_property", 11, "WECGSP", 123)
 

W - Writable
E - Enumerable
C - Configurable
G - Getter
S - Setter
P - Preserve

Title: Re: SBJS
Post by: Mike Lobanovsky on September 14, 2016, 01:50:23 AM

Quote from: John on September 13, 2016, 04:26:51 PM

... I have everything figured out except the OR aspect of these property attributes.

Just in case you're still having difficulties with the C preprocessor, you may wish to use procedural equivalents of the macros on either the SB or C side of the interface. It is feasible, albeit a bit slower than inlined macros.

Consider the following SB routines (SB docs say SB would convert bitwise OR and NOT arguments to integers automatically, and trial shows any IF argument evaluates to TRUE if it is <> 0 or <> FALSE):

Code: Script BASIC

FUNCTION _V7_MK_DESC(v, n)
    IF v THEN
        _V7_MK_DESC = (n OR (n * 0x10000))
    ELSE
        _V7_MK_DESC = INT(n * 0x10000)
    END IF
END FUNCTION

and

Code: Script BASIC

FUNCTION _V7_MK_DESC_INV(v, n)
    _V7_MK_DESC_INV = _V7_MK_DESC(NOT v, n)
END FUNCTION

or their C language equivalents:

Code: C

unsigned long _V7_MK_DESC(int v, unsigned long n) {
    if (v)
        return (n | (n << 16));
    return (n << 16);
}

and

Code: C

unsigned long _V7_MK_DESC_INV(int v, unsigned long n) {
    return _V7_MK_DESC(!v, n);
}

then "functionalize" the other macros at the bottom of your greenish pseudo C header as calls to the two functions above, should you need them too on either side of your interface implementation at all.

Hope this helps.

Title: Re: SBJS
Post by: JRS on September 14, 2016, 08:20:54 AM

Thanks Mike!

This is helpful for the C side of the equation. I like the direction I'm going from the SB side. It's simple to understand and BASIC like.

Title: Re: SBJS
Post by: Charles Pegge on September 15, 2016, 02:34:20 AM

OxygenBasic currently does not support E=( A>B ? C : D ) constructs. I think it will be a useful addition, especially when it turns up in C headers, such as this one. So I will include this capability in the next o2 release.

Title: Re: SBJS
Post by: Mike Lobanovsky on September 15, 2016, 03:01:05 AM

Quote from: Charles Pegge on September 15, 2016, 02:34:20 AM

OxygenBasic currently does not support E=( A>B ? C : D ) constructs.

It's a BASIC IIF(condition, true-result, false-result) function-like implementation of IF/THEN/ELSE with a return value.

Quote

I think it will be a useful addition, especially when it turns up in C headers ...

Try to keep it "short circuited" so that it would only "execute" the condition code and the actual result code and then it would also be usable in its command-like form -- an elegant shorthand for IF/THEN/ELSE impossible in the C language where the ?: ternary operator can only appear as the rhs member of an expression. 8)

Quote

So I will include this capability in the next o2 release.

God bless! :)

Title: Re: SBJS
Post by: JRS on September 15, 2016, 09:16:44 AM

I added Peter Verhas's IFF example in the trial extension module to show how to create a SB COMMAND not function/sub to the JS (JavaScript) extension module as js_iif.

Code: Script BASIC

IMPORT js.bas
 
a = "BASIC"
 
PRINT JS::IIF("BASIC" = a,"TRUE","FALSE"),"\n"
PRINT JS::IIF(a = "CISAB","TRUE","FALSE"),"\n"

jrs@laptop:~/sb/sb22/js$ scriba js_iif.sb TRUE FALSE jrs@laptop:~/sb/sb22/js$

Here is the C extension module code for the IIF() command.

Code: C

besCOMMAND(js_iif)
  DIM AS NODE nItem;
  DIM AS VARIABLE Op1;
  DIM long ConditionValue;
  USE_CALLER_MORTALS;
  nItem = besPARAMETERLIST;
  IF (NOT nItem) THEN
    RESULT = NULL;
    RETURN;
  END_IF
  Op1 = besEVALUATEEXPRESSION(CAR(nItem));
  ASSERTOKE;
  IF (Op1 EQ NULL) THEN
    ConditionValue = 0;
  ELSE
    Op1 = besCONVERT2LONG(Op1);
    ConditionValue = LONGVALUE(Op1);
  END_IF
  IF (NOT ConditionValue) THEN_DO nItem = CDR(nItem);
  IF (NOT nItem) THEN
    RESULT = NULL;
    RETURN;
  END_IF
  nItem = CDR(nItem);
  RESULT = besEVALUATEEXPRESSION(CAR(nItem));
  ASSERTOKE;
  RETURN;
besEND_COMMAND
 

Pushing the envelope a bit.

Code: Script BASIC

IMPORT js.bas
 
FUNCTION T
  T = "True"
END FUNCTION  
  
FUNCTION F
  F = "False"
END FUNCTION  
 
 
a = "BASIC"
 
PRINT JS::IIF("BASIC" = a,T(),F()),"\n"
PRINT JS::IIF(a = "CISAB",T(),F()),"\n"
 

jrs@laptop:~/sb/sb22/js$ scriba js_iif_func.sb True False jrs@laptop:~/sb/sb22/js$

Title: Re: SBJS
Post by: JRS on September 16, 2016, 11:59:47 AM

Mike,

Will something like this work?

Code: Script BASIC

FUNCTION _V7_MK_DESC_INV(v, n)
  _V7_MK_DESC_INV = JS::IIF(v, (n OR (n * 0x10000)), INT(n * 0x10000))
END FUNCTION
 

How do we OR the property attribute flags with JS::DEF()? Can an ORed value be passed and the V7 function will take care of setting the appropriate attributes?

Here is the JS_DEF function for the ext. module. It stills needs the property attribute support either from SB scripting or from the ext. module function.

Code: C

besFUNCTION(js_def)
  DIM AS VARIABLE Argument;
  DIM AS unsigned long v7;
  DIM AS v7_val_t objptr, valueptr;
  DIM AS const char *objname;
  DIM AS size_t objnamelen;
  DIM AS v7_prop_attr_desc_t attrs_desc;
  DIM AS int rtnstatus, i;
  IF (besARGNR < 6) THEN_DO RETURN_FUNCTION(EX_ERROR_TOO_FEW_ARGUMENTS);
  DEF_FOR (i = 1 TO i <= 6 STEP INCR i)
  BEGIN_FOR
    Argument = besARGUMENT(i);
    besDEREFERENCE(Argument);
    IF (i EQ 1) THEN_DO v7 = (unsigned long)LONGVALUE(Argument);
    IF (i EQ 2) THEN_DO objptr = (v7_val_t)LONGVALUE(Argument);
    IF (i EQ 3) THEN_DO objname = STRINGVALUE(Argument);
    IF (i EQ 4) THEN_DO objnamelen = (size_t)LONGVALUE(Argument);
    IF (i EQ 5) THEN_DO attrs_desc = (v7_prop_attr_desc_t)LONGVALUE(Argument);
    IF (i EQ 6) THEN_DO valueptr = (v7_val_t)LONGVALUE(Argument);       
  NEXT
  rtnstatus = v7_def(v7, objptr, objname, objnamelen, attrs_desc, valueptr);
  besRETURN_LONG(rtnstatus);
besEND
 

v eval test

Code: Script BASIC

IMPORT js.bas
 
v = 0
PRINT JS::IIF(v,TRUE,FALSE),"\n"
v = 1
PRINT JS::IIF(v,TRUE,FALSE),"\n"
 

jrs@laptop:~/sb/sb22/js$ scriba js_iif_eval.sb 0 -1 jrs@laptop:~/sb/sb22/js$

Title: Re: SBJS
Post by: Mike Lobanovsky on September 17, 2016, 02:01:36 AM

John,

Please get me right: I am willing to help but my willingness has its reasonable bounds. I don't want to dive into that V7 stuff headlong myself unless absolutely necessary. Before I can give you correct and definitive answers, please gimme yours:

What's the exact purpose of v7_def()? Is it some sort of an entry point to the JS module (.lib/.dll or .a/.so)?
If yes then what's its original declaration (plain C or JS, no CBASIC for me please)?
Is the header you provided used for compiling the V7 sources themselves or is it meant for the V7 end user to utilize it in their C sources to communicate with the precompiled V7 module?

Until you've given me the answers, consider all your JS::/SB code just as a lego for your mind. It yields seemingly correct results but it is unnecessary. I'm telling you you'll get much faster code if you implement _V7_MK_DESC(), _V7_MK_DESC_INV(), IIF() directly in SB than on the other side of your interface where you have to pass, accept, and evaluate a dozen args instead of just two or three in SB.

Your _V7_MK_DESC_INV() is incorrect: that's what _V7_MK_DESC() should do while _V7_MK_DESC_INV() must have inverse logic for its v condition. The former is for setting a property attribute, and the latter, for clearing it. The fastest and easiest way to implement them in SB or C I've already given in my previous message. v is the condition (whose purpose I don't know) and n is obviously the property attribute you're wanting to set or clear, as described in the table Charles has given you earlier in C:

Code: C

#define V7_PROPERTY_NON_WRITABLE     1
#define V7_PROPERTY_NON_ENUMERABLE   2
#define V7_PROPERTY_NON_CONFIGURABLE 4
#define V7_PROPERTY_GETTER           8
#define V7_PROPERTY_SETTER           16
#define _V7_PROPERTY_HIDDEN          32
#define _V7_PROPERTY_OFF_HEAP        64
#define _V7_PROPERTY_USER_DATA_AND_DESTRUCTOR 128
#define _V7_DESC_PRESERVE_VALUE               256
#define _V7_DESC_MASK                         0xffff

or in SB as rewritten below:

Code: Script BASIC

CONST V7_PROPERTY_NON_WRITABLE              = 1
CONST V7_PROPERTY_NON_ENUMERABLE            = 2
CONST V7_PROPERTY_NON_CONFIGURABLE          = 4
CONST V7_PROPERTY_GETTER                    = 8
CONST V7_PROPERTY_SETTER                    = 16
CONST _V7_PROPERTY_HIDDEN                   = 32
CONST _V7_PROPERTY_OFF_HEAP                 = 64
CONST _V7_PROPERTY_USER_DATA_AND_DESTRUCTOR = 128
CONST _V7_DESC_PRESERVE_VALUE               = 256
CONST _V7_DESC_MASK                         = &HFFFF

My guess is they are to be used directly in SB for input to the header's "functionalized" macros whose output should go to v7_def() (or besFUNCTION(js_def)), if it is the entry point they are meant for.

Lastly, your IIF() is not a command, it is a typical function. It is implemented in the BASIC traditional non-short-circuited way (even if it goes to JS for evaluation) which is bug-prone and precludes its use as a command because before it yields its return, whether usable or discardable, it will execute both TRUE and FALSE of its arguments if they are fed to IIF() not as literal values but rather as the results of some external calculus or as other procedures' returns. A true short-circuited-logic command would execute only one of them -- whichever is appropriate for a given condition.

Now please answer my questions before we can proceed.

Title: Re: SBJS
Post by: JRS on September 17, 2016, 09:14:58 AM

Quote

What's the exact purpose of v7_def()? Is it some sort of an entry point to the JS module (.lib/.dll or .a/.so)?

v7_def() defines JavaScript object properties. We are unraveling the attribute argument for the function. Everything else is already written for the v7_def() function.

Quote

If yes then what's its original declaration (plain C or JS, no CBASIC for me please)?

Code: [Select]

/*
 * Property attributes bitmask
 */
typedef unsigned short v7_prop_attr_t;
#define V7_PROPERTY_NON_WRITABLE (1 << 0)
#define V7_PROPERTY_NON_ENUMERABLE (1 << 1)
#define V7_PROPERTY_NON_CONFIGURABLE (1 << 2)
#define V7_PROPERTY_GETTER (1 << 3)
#define V7_PROPERTY_SETTER (1 << 4)
#define _V7_PROPERTY_HIDDEN (1 << 5)
/* property not managed by V7 HEAP */
#define _V7_PROPERTY_OFF_HEAP (1 << 6)
/* special property holding user data and destructor cb */
#define _V7_PROPERTY_USER_DATA_AND_DESTRUCTOR (1 << 7)
/*
 * not a property attribute, but a flag for `v7_def()`. It's here in order to
 * keep all offsets in one place
 */
#define _V7_DESC_PRESERVE_VALUE (1 << 8)

/*
 * Internal helpers for `V7_DESC_...` macros
 */
#define _V7_DESC_SHIFT 16
#define _V7_DESC_MASK ((1 << _V7_DESC_SHIFT) - 1)
#define _V7_MK_DESC(v, n) \
  (((v7_prop_attr_desc_t)(n)) << _V7_DESC_SHIFT | ((v) ? (n) : 0))
#define _V7_MK_DESC_INV(v, n) _V7_MK_DESC(!(v), (n))

/*
 * Property attribute descriptors that may be given to `v7_def()`: for each
 * attribute (`v7_prop_attr_t`), there is a corresponding macro, which takes
 * param: either 1 (set attribute) or 0 (clear attribute). If some particular
 * attribute isn't mentioned at all, it's left unchanged (or default, if the
 * property is being created)
 *
 * There is additional flag: `V7_DESC_PRESERVE_VALUE`. If it is set, the
 * property value isn't changed (or set to `undefined` if the property is being
 * created)
 */
typedef unsigned long v7_prop_attr_desc_t;
#define V7_DESC_WRITABLE(v) _V7_MK_DESC_INV(v, V7_PROPERTY_NON_WRITABLE)
#define V7_DESC_ENUMERABLE(v) _V7_MK_DESC_INV(v, V7_PROPERTY_NON_ENUMERABLE)
#define V7_DESC_CONFIGURABLE(v) _V7_MK_DESC_INV(v, V7_PROPERTY_NON_CONFIGURABLE)
#define V7_DESC_GETTER(v) _V7_MK_DESC(v, V7_PROPERTY_GETTER)
#define V7_DESC_SETTER(v) _V7_MK_DESC(v, V7_PROPERTY_SETTER)
#define V7_DESC_PRESERVE_VALUE _V7_DESC_PRESERVE_VALUE

#define _V7_DESC_HIDDEN(v) _V7_MK_DESC(v, _V7_PROPERTY_HIDDEN)
#define _V7_DESC_OFF_HEAP(v) _V7_MK_DESC(v, _V7_PROPERTY_OFF_HEAP)

/*
 * Define object property, similar to JavaScript `Object.defineProperty()`.
 *
 * `name`, `name_len` specify property name, `val` is a property value.
 * `attrs_desc` is a set of flags which can affect property's attributes,
 * see comment of `v7_prop_attr_desc_t` for details.
 *
 * If `name_len` is ~0, `name` is assumed to be NUL-terminated and
 * `strlen(name)` is used.
 *
 * Returns non-zero on success, 0 on error (e.g. out of memory).
 *
 * See also `v7_set()`.
 */
int v7_def(struct v7 *v7, v7_val_t obj, const char *name, size_t name_len,
           v7_prop_attr_desc_t attrs_desc, v7_val_t v);

Quote

Is the header you provided used for compiling the V7 sources themselves or is it meant for the V7 end user to utilize it in their C sources to communicate with the precompiled V7 module?

The V7 JavaScript Engine / API is made up of two files. (v7.h and v7.c) I include both of these when building my js.so SB C extension module. This allows me to extend SB dynamically with JavaScript OOP functionality as if it were part of Script BASIC.

makefile

Code: C

all : /home/jrs/sb/source/bin/mod/lib/js.a /home/jrs/sb/source/bin/mod/dll/js.so
 
/home/jrs/sb/source/bin/mod/lib/js.a : /home/jrs/sb/source/bin/mod/obj/js/s_interface.o /home/jrs/sb/source/bin/mod/obj/js/js.o 
        ar -r /home/jrs/sb/source/bin/mod/lib/js.a /home/jrs/sb/source/bin/mod/obj/js/s_interface.o /home/jrs/sb/source/bin/mod/obj/js/js.o  
 
/home/jrs/sb/source/bin/mod/dll/js.so : /home/jrs/sb/source/bin/mod/obj/js/interface.o /home/jrs/sb/source/bin/mod/obj/js/js.o 
        ld -shared -fPIC -o /home/jrs/sb/source/bin/mod/dll/js.so /home/jrs/sb/source/bin/mod/obj/js/interface.o /home/jrs/sb/source/bin/mod/obj/js/js.o -lm
 
/home/jrs/sb/source/bin/mod/obj/js/interface.o : interface.c v7.h 
        gcc -O2 -w -m64 -fPIC -c -DV7_BUILD_PROFILE=3 -DCS_ENABLE_UTF8 -DV7_ENABLE_FILE -DV7_ENABLE_SOCKET -o /home/jrs/sb/source/bin/mod/obj/js/interface.o interface.c
 
/home/jrs/sb/source/bin/mod/obj/js/s_interface.o : interface.c v7.h 
        gcc -O2 -w -m64 -fPIC -DSTATIC_LINK=1 -c -DV7_BUILD_PROFILE=3 -DCS_ENABLE_UTF8 -DV7_ENABLE_FILE -DV7_ENABLE_SOCKET -o /home/jrs/sb/source/bin/mod/obj/js/s_interface.o interface.c
 
/home/jrs/sb/source/bin/mod/obj/js/js.o : v7.c 
        gcc -O2 -w -m64 -fPIC -c -DV7_BUILD_PROFILE=3 -DCS_ENABLE_UTF8 -DV7_ENABLE_FILE -DV7_ENABLE_SOCKET -o /home/jrs/sb/source/bin/mod/obj/js/js.o v7.c
 

Ideally I would like to get the property attribute parameter defined in SB and pass as an argument to JS::DEF() which is ready to roll as is. If this isn't practical then doing it just before the call in the ext. module function seeding it from SB script is plan B.

I hope this is enough for us to sync on this and not waste any of your time which I view as precious.

Title: Re: SBJS
Post by: Mike Lobanovsky on September 17, 2016, 11:22:27 AM

Thanks John, this clears things up a lot.

One more Q.: Is SB UTF8 aware?

And yet one more Q.: If yes then how do you specify in the SB code exactly what type of strings you're using for internal purposes and, most importantly, are passing to the outer world, UTF8 or ASCIIZ?

Title: Re: SBJS
Post by: JRS on September 17, 2016, 11:29:57 AM

Quote

One more Q.: Is SB UTF8 aware?

I assume so as all it's script files on Linux are in UTF8 format. (per UltraEdit Linux status line indicator)

Title: Re: SBJS
Post by: Mike Lobanovsky on September 17, 2016, 11:53:19 AM

(Pls see my edit)

I remember you were having difficulties with strings...

Title: Re: SBJS
Post by: JRS on September 17, 2016, 12:17:16 PM

That has been RESOLVED (http://www.allbasic.info/forum/index.php?topic=450.msg4821#msg4821). It was caused by a known but forgotten bug in Script BASIC's nifty variadic argument handler Peter wrote. I had to go back to the old way to get around it and for anything with more than 5 arguments.

Quote

are passing to the outer world, UTF8 or ASCIIZ?

ASCIIZ is my guess. ("z" designator)

SB can also pass binary strings (null embeded) as a "s" type.

Some info on this. (http://www.scriptbasic.org/docs/dg/devguide_4.5.269.html)

Title: Re: SBJS
Post by: Mike Lobanovsky on September 17, 2016, 12:25:13 PM

OK THNX!

Title: Re: SBJS
Post by: JRS on September 17, 2016, 01:23:07 PM

Here is where I'm at with the JS (JavaScript) extension module for Script BASIC.

interface.c

Code: C

/*  V7 JavaScript Engine Extension Module */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <unistd.h>
#include "v7.h"
#include "../../basext.h"
#include "../../scriba.h"
#include "cbasic.h"
 
 
 
/****************************
 Extension Module Functions
****************************/
 
besVERSION_NEGOTIATE
  RETURN_FUNCTION((int)INTERFACE_VERSION);
besEND
 
besSUB_START
  DIM AS long PTR p;
  besMODULEPOINTER = besALLOC(sizeof(long));
  IF (besMODULEPOINTER EQ NULL) THEN_DO RETURN_FUNCTION(0);
  p = (long PTR)besMODULEPOINTER;
  RETURN_FUNCTION(0);
besEND
 
besSUB_FINISH
  DIM AS long PTR p;
  p = (long PTR)besMODULEPOINTER;
  IF (p EQ NULL) THEN_DO RETURN_FUNCTION(0);
  RETURN_FUNCTION(0);
besEND
 
 
/*****************
 Utility Funtions
*****************/
 
besFUNCTION(SB_shifts)
  DIM AS int bp, co, v, x, y, d, p, ar;
  besARGUMENTS("ii[i]")
    AT v, AT p, AT ar
  besARGEND
  IF (ar EQ NULL) THEN_DO ar = 0;
  x = 0xffffffff & v;
  IF (p >= 0) THEN
    y = x << p; // bit shift left
  ELSE
    y = x >> (-p); // bit shift right
  END_IF
//
// SUPPORT FOR ARITHMETIC RIGHT SHIFTS
//
  IF ((ar) AND (p < 0) AND (x & 0x80000000)) THEN
    d = 31 + p;
    IF (d < 0) THEN_DO d = 0; // LIMIT
    bp = 0x80000000;
    DEF_FOR (co = 31 TO co >= d STEP DECR co)
    BEGIN_FOR
      y = y | bp;
      bp = bp >> 1;
    NEXT
  END_IF
  besRETURN_LONG(y);
besEND
 
besFUNCTION(SB_rotates)
  DIM AS int co, v, x, y, d, p, ar;
  besARGUMENTS("ii[i]")
    AT v, AT p, AT ar
  besARGEND
  IF (ar EQ NULL) THEN_DO ar = 0;
  x = 0xffffffff & v;
  d = p;
  IF (d < 0) THEN_DO d=-d;
  DEF_FOR (co = 1 TO co <= d STEP INCR co)
  BEGIN_FOR
    IF (p >= 0) THEN
      y = x << 1; // bit shift left
      IF (x & 0x80000000) THEN_DO y |= 1;
    ELSE
      y = x >> 1; // bit shift right
      IF (x & 1) THEN_DO y |= 0x80000000;
    END_IF
    x = y;
  NEXT
  besRETURN_LONG(y);
besEND
 
besFUNCTION(prop_attr)
  V7_DESC_WRITABLE(1);
  PRINT ("V7_PROPERTY_NON_WRITABLE: %g\n", V7_PROPERTY_NON_WRITABLE);
  PRINT ("V7_PROPERTY_NON_ENUMERABLE: %g\n", V7_PROPERTY_NON_ENUMERABLE);
  PRINT ("V7_PROPERTY_NON_CONFIGURABLE: %g\n", V7_PROPERTY_NON_CONFIGURABLE);
  PRINT ("V7_PROPERTY_GETTER: %g\n", V7_PROPERTY_GETTER);
  PRINT ("V7_PROPERTY_SETTER: %g\n", V7_PROPERTY_SETTER);
  PRINT ("_V7_PROPERTY_HIDDEN: %g\n", _V7_PROPERTY_HIDDEN);
  PRINT ("_V7_PROPERTY_OFF_HEAP: %g\n", _V7_PROPERTY_OFF_HEAP);
  PRINT ("_V7_PROPERTY_USER_DATA_AND_DESTRUCTOR: %g\n", _V7_PROPERTY_USER_DATA_AND_DESTRUCTOR);
  PRINT ("_V7_DESC_PRESERVE_VALUE: %g\n", _V7_DESC_PRESERVE_VALUE);
  besRETURNVALUE = NULL;
besEND
 
besCOMMAND(js_iif)
  DIM AS NODE nItem;
  DIM AS VARIABLE Op1;
  DIM long ConditionValue;
  USE_CALLER_MORTALS;
  nItem = besPARAMETERLIST;
  IF (NOT nItem) THEN
    RESULT = NULL;
    RETURN;
  END_IF
  Op1 = besEVALUATEEXPRESSION(CAR(nItem));
  ASSERTOKE;
  IF (Op1 EQ NULL) THEN
         ConditionValue = 0;
  ELSE
    Op1 = besCONVERT2LONG(Op1);
    ConditionValue = LONGVALUE(Op1);
  END_IF
  IF (NOT ConditionValue) THEN_DO nItem = CDR(nItem);
  IF (NOT nItem) THEN
    RESULT = NULL;
    RETURN;
  END_IF
  nItem = CDR(nItem);
  RESULT = besEVALUATEEXPRESSION(CAR(nItem));
  ASSERTOKE;
  RETURN;
besEND_COMMAND
 
 
/*******
 V7 API
*******/
 
besFUNCTION(js_create)
  struct v7 *v7 = v7_create();
  besRETURN_LONG(v7);
besEND
 
besFUNCTION(js_destroy)
  DIM AS unsigned long v7;
  besARGUMENTS("i")
    AT v7
  besARGEND
  v7_destroy(v7);
  besRETURNVALUE = NULL;
besEND
 
besFUNCTION(js_exec)
  VARIABLE Argument;
  LEFTVALUE Lval;
  unsigned long __refcount_;
  DIM AS unsigned long v7;
  DIM AS const char *js_code;
  DIM AS v7_val_t result;
  enum v7_err rcode = V7_OK;
  besARGUMENTS("iz")
    AT v7, AT js_code
  besARGEND
  rcode = v7_exec(v7, js_code, &result);
  Argument = besARGUMENT(3);
  besLEFTVALUE(Argument,Lval);
  besRELEASE(*Lval);
  *Lval = besNEWLONG;
  LONGVALUE(*Lval) = rcode;
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_get_int)
  DIM AS unsigned long v7;
  DIM AS v7_val_t resultptr;
  DIM AS int rtnval;
  besARGUMENTS("ii")
    AT v7, AT resultptr
  besARGEND
  rtnval = v7_get_int(v7, resultptr);
  besRETURN_LONG(rtnval);
besEND
 
besFUNCTION(js_get_double)
  DIM AS unsigned long v7;
  DIM AS v7_val_t resultptr;
  DIM AS double rtnval;
  besARGUMENTS("ii")
    AT v7, AT resultptr
  besARGEND
  rtnval = v7_get_double(v7, resultptr);
  besRETURN_DOUBLE(rtnval);
besEND
 
besFUNCTION(js_get_string)
  DIM AS unsigned long v7;
  DIM AS v7_val_t resultptr;
  DIM const char *sbstr;
  DIM size_t *strsize;
  besARGUMENTS("ii")
    AT v7, AT resultptr
  besARGEND
  sbstr = v7_get_string(v7, &resultptr, NULL);
  besRETURN_STRING(sbstr);
besEND
 
besFUNCTION(js_get)
  DIM AS unsigned long v7;
  DIM AS v7_val_t obj, result;
  DIM AS const char *name;
  DIM AS size_t name_len;
  besARGUMENTS("iizi")
    AT v7, AT obj, AT name, AT name_len
  besARGEND
  result = v7_get(v7, obj, name, name_len);
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_get_global)
  DIM AS unsigned long v7;
  DIM AS v7_val_t result;
  besARGUMENTS("i")
    AT v7
  besARGEND
  result = v7_get_global(v7);
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_mk_array)
  DIM AS unsigned long v7;
  DIM AS v7_val_t result;
  besARGUMENTS("i")
    AT v7
  besARGEND
  result = v7_mk_array(v7);
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_array_push)
  DIM AS unsigned long v7;
  DIM AS v7_val_t arrayptr, arrayval;
  DIM AS int rtncode;
  besARGUMENTS("iii")
    AT v7, AT arrayptr, AT arrayval
  besARGEND
  rtncode = v7_array_push(v7, arrayptr, arrayval);
  besRETURN_LONG(rtncode);
besEND
 
besFUNCTION(js_mk_number)
  DIM AS unsigned long v7;
  DIM AS double numval;
  DIM AS v7_val_t result;
  besARGUMENTS("ir")
    AT v7, AT numval
  besARGEND
  result = v7_mk_number(v7, numval);
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_apply)
  VARIABLE Argument;
  LEFTVALUE Lval;
  unsigned long __refcount_;
  DIM AS unsigned long v7;
  DIM AS v7_val_t funcptr, objptr, argsptr, result;
  enum v7_err rtncode = V7_OK;
  besARGUMENTS("iiii")
    AT v7, AT funcptr, AT objptr, AT argsptr
  besARGEND
  IF (objptr == 0) THEN
    rtncode = v7_apply(v7, funcptr, V7_UNDEFINED, argsptr, &result);
  ELSE
        rtncode = v7_apply(v7, funcptr, objptr, argsptr, &result);
  END_IF
  Argument = besARGUMENT(4);
  besLEFTVALUE(Argument,Lval);
  besRELEASE(*Lval);
  *Lval = besNEWLONG;
  LONGVALUE(*Lval) = rtncode;
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_get_this)
  DIM AS unsigned long v7;
  DIM AS v7_val_t result;
  besARGUMENTS("i")
    AT v7
  besARGEND
  result = v7_get_this(v7);
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_get_arguments)
  DIM AS unsigned long v7;
  DIM AS v7_val_t result;
  besARGUMENTS("i")
    AT v7
  besARGEND
  result = v7_get_arguments(v7);
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_arg)
  DIM AS unsigned long v7, arrayidx;
  DIM AS v7_val_t result;
  besARGUMENTS("ii")
    AT v7, AT arrayidx
  besARGEND
  result = v7_arg(v7, arrayidx);
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_argc)
  DIM AS unsigned long v7, arglen;
  besARGUMENTS("i")
    AT v7
  besARGEND
  arglen = v7_argc(v7);
  besRETURN_LONG(arglen);
besEND
 
besFUNCTION(js_own)
  DIM AS unsigned long v7;
  DIM AS v7_val_t *cvar;
  besARGUMENTS("ii")
    AT v7, AT cvar
  besARGEND
  v7_own(v7, &cvar);
  besRETURNVALUE = NULL;
besEND
 
besFUNCTION(js_disown)
  DIM AS unsigned long v7;
  DIM AS v7_val_t *cvar;
  DIM AS int found;
  besARGUMENTS("ii")
    AT v7, AT cvar
  besARGEND
  found = v7_disown(v7, &cvar);
  besRETURN_LONG(found);
besEND
 
besFUNCTION(js_get_parser_error)
  DIM AS unsigned long v7;
  DIM AS const char *errstr;
  besARGUMENTS("i")
    AT v7
  besARGEND
  errstr = v7_get_parser_error(v7);
  besRETURN_STRING(errstr);
besEND
 
besFUNCTION(js_is_number)
  DIM AS v7_val_t varptr;
  DIM AS int istrue;
  besARGUMENTS("i")
    AT varptr
  besARGEND
  istrue = v7_is_number(varptr);
  besRETURN_LONG(istrue);
besEND
 
besFUNCTION(js_mk_boolean)
  DIM AS unsigned long v7;
  DIM AS v7_val_t boolptr;
  DIM AS int istrue;
  besARGUMENTS("ii")
    AT v7, AT istrue
  besARGEND
  boolptr = v7_mk_boolean(v7, istrue);
  besRETURN_LONG(boolptr);
besEND
 
besFUNCTION(js_get_bool)
  DIM AS unsigned long v7;
  DIM AS v7_val_t boolptr;
  DIM AS int truefalse;
  besARGUMENTS("ii")
    AT v7, AT truefalse
  besARGEND
  truefalse = v7_get_bool(v7, boolptr);
  besRETURN_LONG(truefalse);
besEND
 
besFUNCTION(js_is_boolean)
  DIM AS v7_val_t boolptr;
  DIM AS int istrue;
  besARGUMENTS("i")
    AT boolptr
  besARGEND
  istrue = v7_is_boolean(boolptr);
  besRETURN_LONG(istrue);
besEND
 
besFUNCTION(js_mk_null)
  DIM AS v7_val_t result;
  result = V7_NULL;
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_is_null)
  DIM AS v7_val_t nullptr;
  DIM AS int istrue;
  besARGUMENTS("i")
    AT nullptr
  besARGEND
  istrue = v7_is_null(nullptr);
  besRETURN_LONG(istrue);
besEND
 
besFUNCTION(js_mk_undefined)
  DIM AS v7_val_t result;
  result = V7_UNDEFINED;
  besRETURN_LONG(result);
besEND
 
besFUNCTION(js_is_undefined)
  DIM AS v7_val_t undefptr;
  DIM AS int istrue;
  besARGUMENTS("i")
    AT undefptr
  besARGEND
  istrue = v7_is_undefined(undefptr);
  besRETURN_LONG(istrue);
besEND
 
/* HACK - "izii" mask broken - using old school method
besFUNCTION(js_mk_string)
  DIM AS unsigned long v7;
  DIM AS v7_val_t rtnstrptr;
  DIM AS char *jsstr;
  DIM AS size_t jsstrlen;
  DIM AS int jsstrcopy;
  besARGUMENTS("izi")
//  AT v7, AT jsstr, AT jsstrlen, AT jsstrcopy
    AT v7, AT jsstr, AT jsstrlen
  besARGEND
//  rtnstrptr = v7_mk_string(v7, jsstr, jsstrlen, jsstrcopy);
    rtnstrptr = v7_mk_string(v7, jsstr, jsstrlen, 1);
  besRETURN_LONG(rtnstrptr);
besEND
*/
 
besFUNCTION(js_mk_string)
  DIM AS VARIABLE Argument;
  DIM AS unsigned long v7;
  DIM AS char *jsstr;
  DIM AS size_t jsstrlen;
  DIM AS int jsstrcopy, i;
  DIM AS v7_val_t rtnstrptr;
  IF (besARGNR < 4) THEN_DO RETURN_FUNCTION(EX_ERROR_TOO_FEW_ARGUMENTS);
  DEF_FOR (i = 1 TO i <= 4 STEP INCR i)
  BEGIN_FOR
    Argument = besARGUMENT(i);
    besDEREFERENCE(Argument);
    IF (i EQ 1) THEN_DO v7 = (unsigned long)LONGVALUE(Argument);
    IF (i EQ 2) THEN_DO jsstr = STRINGVALUE(Argument);
    IF (i EQ 3) THEN_DO jsstrlen = (size_t)LONGVALUE(Argument);
    IF (i EQ 4) THEN_DO jsstrcopy = (int)LONGVALUE(Argument);
  NEXT
  rtnstrptr = v7_mk_string(v7, jsstr, jsstrlen, jsstrcopy);
  besRETURN_LONG(rtnstrptr);
besEND
 
besFUNCTION(js_is_string)
  DIM AS v7_val_t jsstrptr;
  DIM AS int istrue;
  besARGUMENTS("i")
    AT jsstrptr
  besARGEND
  istrue = v7_is_string(jsstrptr);
  besRETURN_LONG(istrue);
besEND
 
besFUNCTION(js_get_cstring)
  DIM AS unsigned long v7;
  DIM AS v7_val_t cstrptr;
  DIM const char *sbcstr;
  DIM size_t *cstrlen;
  besARGUMENTS("iii")
    AT v7, AT cstrptr, AT cstrlen
  besARGEND
  sbcstr = v7_get_string(v7, &cstrptr, &cstrlen);
  besRETURN_STRING(sbcstr);
besEND
 
besFUNCTION(js_mk_object)
  DIM AS unsigned long v7;
  DIM AS v7_val_t objptr;
  besARGUMENTS("i")
    AT v7
  besARGEND
  objptr = v7_mk_object(v7);
  besRETURN_STRING(objptr);
besEND
 
besFUNCTION(js_is_object)
  DIM AS v7_val_t objptr;
  DIM AS int istrue;
  besARGUMENTS("i")
    AT objptr
  besARGEND
  istrue = v7_is_object(objptr);
  besRETURN_LONG(istrue);
besEND
 
besFUNCTION(js_set_proto)
  DIM AS unsigned long v7;
  DIM AS v7_val_t objptr, protoptr, oldprotoptr;
  besARGUMENTS("iii")
    AT v7, AT objptr, AT protoptr
  besARGEND
  oldprotoptr = v7_set_proto(v7, objptr, protoptr);
  besRETURN_LONG(oldprotoptr);
besEND
 
 
besFUNCTION(js_def)
  DIM AS VARIABLE Argument;
  DIM AS unsigned long v7;
  DIM AS v7_val_t objptr, valueptr;
  DIM AS const char *objname;
  DIM AS size_t objnamelen;
  DIM AS v7_prop_attr_desc_t attrs_desc;
  DIM AS int rtnstatus, i;
  IF (besARGNR < 6) THEN_DO RETURN_FUNCTION(EX_ERROR_TOO_FEW_ARGUMENTS);
  DEF_FOR (i = 1 TO i <= 6 STEP INCR i)
  BEGIN_FOR
    Argument = besARGUMENT(i);
    besDEREFERENCE(Argument);
    IF (i EQ 1) THEN_DO v7 = (unsigned long)LONGVALUE(Argument);
    IF (i EQ 2) THEN_DO objptr = (v7_val_t)LONGVALUE(Argument);
    IF (i EQ 3) THEN_DO objname = STRINGVALUE(Argument);
    IF (i EQ 4) THEN_DO objnamelen = (size_t)LONGVALUE(Argument);
    IF (i EQ 5) THEN_DO attrs_desc = (v7_prop_attr_desc_t)LONGVALUE(Argument);
    IF (i EQ 6) THEN_DO valueptr = (v7_val_t)LONGVALUE(Argument);       
  NEXT
  rtnstatus = v7_def(v7, objptr, objname, objnamelen, attrs_desc, valueptr);
  besRETURN_LONG(rtnstatus);
besEND
 

js.bas (SB IMPORT)

Code: Script BASIC

MODULE JS
                                                                   
DECLARE SUB      ::CREATE               ALIAS "js_create"             LIB "js"
DECLARE SUB      ::DESTROY              ALIAS "js_destroy"            LIB "js"
DECLARE SUB      ::EXEC                 ALIAS "js_exec"               LIB "js"
DECLARE SUB      ::APPLY                ALIAS "js_apply"              LIB "js"
DECLARE SUB      ::OWN                  ALIAS "js_own"                LIB "js"
DECLARE SUB      ::DISOWN               ALIAS "js_disown"             LIB "js"
DECLARE SUB      ::GET_INT              ALIAS "js_get_int"            LIB "js"
DECLARE SUB      ::GET_DOUBLE           ALIAS "js_get_double"         LIB "js"
DECLARE SUB      ::GET_STRING           ALIAS "js_get_string"         LIB "js"
DECLARE SUB      ::GET_CSTRING          ALIAS "js_get_cstring"        LIB "js"
DECLARE SUB      ::GET_BOOL             ALIAS "js_get_bool"           LIB "js"
DECLARE SUB      ::GET                  ALIAS "js_get"                LIB "js"
DECLARE SUB      ::GET_GLOBAL           ALIAS "js_get_global"         LIB "js"
DECLARE SUB      ::GET_THIS             ALIAS "js_get_this"           LIB "js"
DECLARE SUB      ::GET_ARGUMENTS        ALIAS "js_get_arguments"      LIB "js"
DECLARE SUB      ::ARG                  ALIAS "js_get_arg"            LIB "js"
DECLARE SUB      ::ARGC                 ALIAS "js_get_argc"           LIB "js"
DECLARE SUB      ::ARRAY_PUSH           ALIAS "js_array_push"         LIB "js"
DECLARE SUB      ::MK_ARRAY             ALIAS "js_mk_array"           LIB "js"
DECLARE SUB      ::MK_BOOLEAN           ALIAS "js_mk_boolean"         LIB "js"
DECLARE SUB      ::MK_NUMBER            ALIAS "js_mk_number"          LIB "js"
DECLARE SUB      ::MK_STRING            ALIAS "js_mk_string"          LIB "js"
DECLARE SUB      ::MK_UNDEFINED         ALIAS "js_mk_undefined"       LIB "js"
DECLARE SUB      ::MK_NULL              ALIAS "js_mk_null"            LIB "js"
DECLARE SUB      ::MK_OBJECT            ALIAS "js_mk_object"          LIB "js"
DECLARE SUB      ::IS_NUMBER            ALIAS "js_is_number"          LIB "js"
DECLARE SUB      ::IS_STRING            ALIAS "js_is_string"          LIB "js"
DECLARE SUB      ::IS_BOOLEAN           ALIAS "js_is_boolean"         LIB "js"
DECLARE SUB      ::IS_NULL              ALIAS "js_is_null"            LIB "js"
DECLARE SUB      ::IS_UNDEFINED         ALIAS "js_is_undefined"       LIB "js"
DECLARE SUB      ::IS_OBJECT            ALIAS "js_is_object"          LIB "js"
DECLARE SUB      ::SET_PROTO            ALIAS "js_set_proto"          LIB "js"
DECLARE SUB      ::DEF                  ALIAS "js_def"                LIB "js"
DECLARE SUB      ::GET_ERROR            ALIAS "js_get_parser_error"   LIB "js"
 
' Utility Functions
DECLARE SUB      ::BITSHIFT             ALIAS "SB_shifts"             LIB "js"
DECLARE COMMAND  ::IIF                  ALIAS "js_iif"                LIB "js"
 
END MODULE
 

Title: Re: SBJS
Post by: JRS on September 17, 2016, 01:38:04 PM

Quote

Lastly, your IIF() is not a command, it is a typical function.

Maybe Peter had it right all along. IFF (IF Function)

I wouldn't call it only a function as functions don't do evaluations within an argument. I think it's cool you can embed an IF as if it were a function.

Title: Re: SBJS
Post by: JRS on September 17, 2016, 09:29:13 PM

Quote

There is additional flag: V7_DESC_PRESERVE_VALUE. If it is set, the property value isn't changed (or set to undefined if the property is being created)

I think I misunderstood the preserve functionality. It relates to the property value not property attribute states.

HERE (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty) is a helpful link in understanding what we are doing with v7_def() as if we were doing a Object.defineProperty() in JavaScript.

It seems these property attributes are referred to as keys in JavaScript terms.

Title: Re: SBJS
Post by: JRS on September 18, 2016, 08:43:04 AM

I see we are overwhelming the O2 forum with the Script BASIC JavaScript project and I would like to return the thread to All BASIC (http://www.allbasic.info/forum/index.php?topic=450.0). Both Mike and Charles are members there if you wish to participate with this effort.

Thanks Charles and Mike for all your help!

Oxygen Basic

Information => Open Forum => Topic started by: JRS on September 12, 2016, 09:12:35 AM