Bits (0,1) vs. Bytes vs. Short vs. Int vs. Long

[ThSITC]

IBM NetRexx seems (according to my trials) a nic (?) behaviour:

If I do have dd design (in my class InCompute)  a method in_right_side,
and I would like to have a BOOLEAN parameter is_param, with a default
value of
FALSE (0), then, in NetRexx:

     jj=o_compute.in_right_side(1)

does give a FATAL error message!

method in_right_side(is_param=boolean 0))

    ... details in CODE Below!

I would REALLY Like, when ANYBODY, may it be Rene, MFC, *or* anyone else,
could START to FIX this (very small, but *annoying* problems, please :-)

(Massa) Thomas.

As attached files are NOT supported in this community,

*Here is the (my) SOURCE*
=======================================================================================
-- trace all
/**********************************************************************/
/* InCompute: Generalized implementation of the COMPUTE (assignment)  */
/*          : statement for ALL languages                             */
/**********************************************************************/
/*   (c) Th.Schneider, 2004-2010                                      */
/**********************************************************************/
/* 10.02.2010: Support for compound assignment operators added        */
/* 20.08.2010: Code revised for Java and C++, C#                      */
/*           : the various checks are now delayed to the Analyser     */
/*           : in any case to speed up initial Parse, and also as     */
/*           : the various classes are not yet available in Pass 1    */
/*           : multiple assignments not yet supported (PL/I)          */
/* 16.04.2011: options binary added for utmost speed                  */
/*           : Note that NetRexx Type parsing is stll an open issue!  */
/**********************************************************************/

options binary
package com.thsitc.rey.in -- note that InCompute is common for all languages

import com.thsitc.pp.rt.
import com.thsitc.rey.rt.

class InCompute extends Object uses ReyMsg -- General version, all languages

properties public static

o_scan = Scan
o_item = InItem
o_expr = Inexpr

target_nos = Rexx -- item number LIST in case of PL/I (and Rey)
target_no= int 0
op_code=int -- integer op_code
source_expr_no=int 0
debug=Options.opt_debug
terminators=''

method InCompute(x_scan=scan) public -- the constructor
    o_scan=x_scan
    if o_Item=Null then o_item=InItem(o_scan)
    if o_expr=Null then o_expr=InExpr(o_scan)
           -- o_scan.display_reserved('At InCompute') -- debug
    return

method in_COMPUTE() public ;
    if o_scan.EOL() then ReyMsg.abort('unexpected InCompute-call at EOL!')

    -- terminators=o_scan.ASN_ops o_scan.EOS
    -- o_scan.set_phrase_terminators(terminators)

    o_scan.is_LHS=1 -- we are on the left hand side of a COMPUTE
    o_scan.is_ASSIGN=0 -- we do NOT yet know whether it ia an ASSIGNMENT
    -- as it may be a COMMAND or method invokatiion as well !

    if o_scan.verb <> 'COMPUTE' then ReyMsg.abort('InClause error,
verb=' o_scan.verb 'is NOT Compute!')
    /* note that 'COMPUTE' is the default verb assigned by Scan, when no
verb is present */

    target_nos=''

    target_nos= in_left_side()
    -- ReyMsg.debug('InCompute: Left side is:' Items.ThisItem(target_nos))

    if o_scan.EOC() | o_scan.EOL() then return -- was a method
invocation or a command
    /* note that the actual EOS character is processed by InClause */

    operator=o_scan.in_token()
    op_code = o_scan.token_code

    if op_code=11 then do
       o_scan.token_code=90 -- cheat parser, = means assignment op in
Compute
       o_scan.token_class='Assign'
       op_code=90
    end

    if debug then ReyMsg.debug('InCompute: Operator=' o_scan.ThisToken()
'op_code:' op_code)

    if \o_scan.isAssignOp(operator) then do
       ReyMsg.error('Invalid operator:' operator '(op-code:' op_code')
for assignment')
       o_scan.skip_statement
       return
    end

    if o_scan.token_level>0 then do
       ReyMsg.error('missing parenthesis/bracket before' o_scan.ThisToken())
       o_scan.token_level=0
    end

    o_scan.out_token() -- accept operator (may be =, +=, etc now, but
coded OP is used

    source_expr_no= in_right_side()
    if debug then ReyMsg.debug('InCompute: Right side is:'
Items.ThisItem(source_expr_no))

    if source_expr_no = 0 then ReyMsg.abort('source expression missing!')

    /* Finally EMIT the code */
    select case op_code
       when 90 then Code.ExCode('ASN' source_expr_no target_nos)
       when 91 then Code.ExCode('ADD' source_expr_no target_nos)
       when 92 then Code.ExCode('SUB' source_expr_no target_nos)
       when 93 then Code.ExCode('MUL' source_expr_no target_nos)
       when 94 then Code.ExCode('DIV' source_expr_no target_nos)
       when 95 then Code.ExCode('POW' source_expr_no target_nos)
       when 96 then Code.ExCode('REM' source_expr_no target_nos) --
REMAINDER, NOT modulo
       when 97 then Code.ExCode('DIVI' source_expr_no target_nos) --
INTEGER DIVISION
       otherwise
          ReyMsg.error('Operator:' Operator '(op_code:' op_code') not
yet supported by InCompute!')
    end

    if  \o_scan.EOC & \o_scan.EOL then do
       ReyMsg.ic_error=ReyMsg.ic2
       ReyMsg.error('premature end of statement, rest of statement ignored')
       o_scan.skip_statement
    end--if

    -- ReyMsg.debug('end assign, operator was:' operator '(op-code:'
op_code')')
    return

method in_left_side() public returns Rexx -- may be list of item-numbers

    Global.action = 'COMPUTE'

    o_scan.is_LHS=1 /* left hand side flag */
    list= Rexx '' /* the target item number or item-number-list */

    /* note that literals are NOT allowed on the left hand side */
    select case o_scan.language
       when 'COBOL' then list=o_item.in_item(1)
       when 'PLI','Rey' then list=o_item.in_item_list(1) -- note that
PLI and Rey do support multiple assignments
       when 'Rexx','ooRexx','Regina','NetRexx' then list=o_item.in_item(1)
       when 'Java','C','C++','C#' then list=o_item.in_item(11) -- may be
prefixed by attributes
       otherwise do
          ReyMsg.error('Language:' o_scan.language 'not yet supported by
InCompute')
          o_scan.skip_statement()
       end
    end

    if list=0 | list='' then abort('Parser/Program error, left side is
empty!')
    if debug then ReyMsg.debug('InCompute: left side(target) is:'
Items.ThisItem(list))

    if o_scan.EOC() then do -- test for End Of Clause (EOC)
       select case o_scan.language

            when 'Rey','NetRexx' then do
               Code.ExCode('X' list) -- EXECUTE Method(s)
               return 0
            end
            when 'COBOL','PLI' then do
               ReyMsg.error('Assignment Operator expected, but found:'
o_scan.ThisToken())
               return 0
            end
         when 'Rexx','ooRexx','Regina' then do
            Code.ExCode('CMD' list)
            return 0
         end
         otherwise do
            ReyMsg.error('Language:' o_scan.language 'not yet supported
by InCompute')
            o_scan.skip_statement
            return 0
         end
       end

    end -- note that EOS remains in input stream, as it is processed by
InClause

    return list -- return coded left side (may be an item-number or an
item-number-list)

/*********************************************************/
/* In right side: get right side of the assignment       */
/* the corresponding left hand side item is now passed   */
/* as a parameter                                        */
/*********************************************************/

method in_right_side(is_param=boolean 0)  public returns int;
    o_scan.is_LHS=0   -- set flag
    o_scan.is_assign=1

    /* note that right hand side may be any expression, even in
declarations */
    if is_param then ii_right=o_expr.in_expression(11) -- Parameter
syntax expected
    else ii_right= o_expr.in_expression(7) --any expression allowed on
right side
    -- nbote that in_right side is also used for Parameters
    if ii_right=0 then ReyMsg.abort('Parser/Program error, right side is
empty!')
    return ii_right



--
Thomas Schneider (www.thsitc.com)
_______________________________________________
Ibm-netrexx mailing list
[hidden email]

[measel]

...
Class InCompute
... true = boolean 1
    false = boolean 0
....
     jj=o_comput.in_right_side(true)
...
method in_right_side(is_param boolean)
   whatever()
...

-----Original Message-----
From: [hidden email] on behalf of Thomas Schneider
Sent: Thu 4/21/2011 1:48 PM
To: IBM Netrexx
Subject: [Ibm-netrexx] Bits (0,1) vs. Bytes vs. Short vs. Int vs. LongT
 
IBM NetRexx seems (according to my trials) a nic (?) behaviour:

If I do have dd design (in my class InCompute)  a method in_right_side,
and I would like to have a BOOLEAN parameter is_param, with a default
value of
FALSE (0), then, in NetRexx:

     jj=o_compute.in_right_side(1)

does give a FATAL error message!

method in_right_side(is_param=boolean 0))

    ... details in CODE Below!

I would REALLY Like, when ANYBODY, may it be Rene, MFC, *or* anyone else,
could START to FIX this (very small, but *annoying* problems, please :-)

(Massa) Thomas.

As attached files are NOT supported in this community,

*Here is the (my) SOURCE*
=======================================================================================
-- trace all
/**********************************************************************/
/* InCompute: Generalized implementation of the COMPUTE (assignment)  */
/*          : statement for ALL languages                             */
/**********************************************************************/
/*   (c) Th.Schneider, 2004-2010                                      */
/**********************************************************************/
/* 10.02.2010: Support for compound assignment operators added        */
/* 20.08.2010: Code revised for Java and C++, C#                      */
/*           : the various checks are now delayed to the Analyser     */
/*           : in any case to speed up initial Parse, and also as     */
/*           : the various classes are not yet available in Pass 1    */
/*           : multiple assignments not yet supported (PL/I)          */
/* 16.04.2011: options binary added for utmost speed                  */
/*           : Note that NetRexx Type parsing is stll an open issue!  */
/**********************************************************************/

options binary
package com.thsitc.rey.in -- note that InCompute is common for all languages

import com.thsitc.pp.rt.
import com.thsitc.rey.rt.

class InCompute extends Object uses ReyMsg -- General version, all languages

properties public static

o_scan = Scan
o_item = InItem
o_expr = Inexpr

target_nos = Rexx -- item number LIST in case of PL/I (and Rey)
target_no= int 0
op_code=int -- integer op_code
source_expr_no=int 0
debug=Options.opt_debug
terminators=''

method InCompute(x_scan=scan) public -- the constructor
    o_scan=x_scan
    if o_Item=Null then o_item=InItem(o_scan)
    if o_expr=Null then o_expr=InExpr(o_scan)
           -- o_scan.display_reserved('At InCompute') -- debug
    return

method in_COMPUTE() public ;
    if o_scan.EOL() then ReyMsg.abort('unexpected InCompute-call at EOL!')

    -- terminators=o_scan.ASN_ops o_scan.EOS
    -- o_scan.set_phrase_terminators(terminators)

    o_scan.is_LHS=1 -- we are on the left hand side of a COMPUTE
    o_scan.is_ASSIGN=0 -- we do NOT yet know whether it ia an ASSIGNMENT
    -- as it may be a COMMAND or method invokatiion as well !

    if o_scan.verb <> 'COMPUTE' then ReyMsg.abort('InClause error,
verb=' o_scan.verb 'is NOT Compute!')
    /* note that 'COMPUTE' is the default verb assigned by Scan, when no
verb is present */

    target_nos=''

    target_nos= in_left_side()
    -- ReyMsg.debug('InCompute: Left side is:' Items.ThisItem(target_nos))

    if o_scan.EOC() | o_scan.EOL() then return -- was a method
invocation or a command
    /* note that the actual EOS character is processed by InClause */

    operator=o_scan.in_token()
    op_code = o_scan.token_code

    if op_code=11 then do
       o_scan.token_code=90 -- cheat parser, = means assignment op in
Compute
       o_scan.token_class='Assign'
       op_code=90
    end

    if debug then ReyMsg.debug('InCompute: Operator=' o_scan.ThisToken()
'op_code:' op_code)

    if \o_scan.isAssignOp(operator) then do
       ReyMsg.error('Invalid operator:' operator '(op-code:' op_code')
for assignment')
       o_scan.skip_statement
       return
    end

    if o_scan.token_level>0 then do
       ReyMsg.error('missing parenthesis/bracket before' o_scan.ThisToken())
       o_scan.token_level=0
    end

    o_scan.out_token() -- accept operator (may be =, +=, etc now, but
coded OP is used

    source_expr_no= in_right_side()
    if debug then ReyMsg.debug('InCompute: Right side is:'
Items.ThisItem(source_expr_no))

    if source_expr_no = 0 then ReyMsg.abort('source expression missing!')

    /* Finally EMIT the code */
    select case op_code
       when 90 then Code.ExCode('ASN' source_expr_no target_nos)
       when 91 then Code.ExCode('ADD' source_expr_no target_nos)
       when 92 then Code.ExCode('SUB' source_expr_no target_nos)
       when 93 then Code.ExCode('MUL' source_expr_no target_nos)
       when 94 then Code.ExCode('DIV' source_expr_no target_nos)
       when 95 then Code.ExCode('POW' source_expr_no target_nos)
       when 96 then Code.ExCode('REM' source_expr_no target_nos) --
REMAINDER, NOT modulo
       when 97 then Code.ExCode('DIVI' source_expr_no target_nos) --
INTEGER DIVISION
       otherwise
          ReyMsg.error('Operator:' Operator '(op_code:' op_code') not
yet supported by InCompute!')
    end

    if  \o_scan.EOC & \o_scan.EOL then do
       ReyMsg.ic_error=ReyMsg.ic2
       ReyMsg.error('premature end of statement, rest of statement ignored')
       o_scan.skip_statement
    end--if

    -- ReyMsg.debug('end assign, operator was:' operator '(op-code:'
op_code')')
    return

method in_left_side() public returns Rexx -- may be list of item-numbers

    Global.action = 'COMPUTE'

    o_scan.is_LHS=1 /* left hand side flag */
    list= Rexx '' /* the target item number or item-number-list */

    /* note that literals are NOT allowed on the left hand side */
    select case o_scan.language
       when 'COBOL' then list=o_item.in_item(1)
       when 'PLI','Rey' then list=o_item.in_item_list(1) -- note that
PLI and Rey do support multiple assignments
       when 'Rexx','ooRexx','Regina','NetRexx' then list=o_item.in_item(1)
       when 'Java','C','C++','C#' then list=o_item.in_item(11) -- may be
prefixed by attributes
       otherwise do
          ReyMsg.error('Language:' o_scan.language 'not yet supported by
InCompute')
          o_scan.skip_statement()
       end
    end

    if list=0 | list='' then abort('Parser/Program error, left side is
empty!')
    if debug then ReyMsg.debug('InCompute: left side(target) is:'
Items.ThisItem(list))

    if o_scan.EOC() then do -- test for End Of Clause (EOC)
       select case o_scan.language

            when 'Rey','NetRexx' then do
               Code.ExCode('X' list) -- EXECUTE Method(s)
               return 0
            end
            when 'COBOL','PLI' then do
               ReyMsg.error('Assignment Operator expected, but found:'
o_scan.ThisToken())
               return 0
            end
         when 'Rexx','ooRexx','Regina' then do
            Code.ExCode('CMD' list)
            return 0
         end
         otherwise do
            ReyMsg.error('Language:' o_scan.language 'not yet supported
by InCompute')
            o_scan.skip_statement
            return 0
         end
       end

    end -- note that EOS remains in input stream, as it is processed by
InClause

    return list -- return coded left side (may be an item-number or an
item-number-list)

/*********************************************************/
/* In right side: get right side of the assignment       */
/* the corresponding left hand side item is now passed   */
/* as a parameter                                        */
/*********************************************************/

method in_right_side(is_param=boolean 0)  public returns int;
    o_scan.is_LHS=0   -- set flag
    o_scan.is_assign=1

    /* note that right hand side may be any expression, even in
declarations */
    if is_param then ii_right=o_expr.in_expression(11) -- Parameter
syntax expected
    else ii_right= o_expr.in_expression(7) --any expression allowed on
right side
    -- nbote that in_right side is also used for Parameters
    if ii_right=0 then ReyMsg.abort('Parser/Program error, right side is
empty!')
    return ii_right



--
Thomas Schneider (www.thsitc.com)
_______________________________________________
Ibm-netrexx mailing list
[hidden email]



_______________________________________________
Ibm-netrexx mailing list
[hidden email]

[ThSITC]

HI Mike,
    (and all)

1.) OF COURSE, you are TRUE (and, trust me, I do know this TRUE, FALSE,
and also an OVERCOME)

2.) My question is: why CANNOT we PLEASE DEFINE TRUE and FALSE, and UNKNOWN
*at the first instance* (tri-dimensional, NOT BINRAY, of course) ;-)

3.) I do have NO problems to ix any problems in my NetRexx Source,
detecting ANY/ALL
potential PROBLEMS. Trust me, please, again I DO know NetRexx quite well :-)

4.) What I do HATE: Quiet IBM-NetRexx Group, no enhancements, NO Bug Fixes!

Have a nice EASTER, anyway...

Massa Thomas.
=========================================================================================

Am 21.04.2011 21:21, schrieb Measel, Mike:

> ...
> Class InCompute
> ... true = boolean 1
>      false = boolean 0
> ....
>       jj=o_comput.in_right_side(true)
> ...
> method in_right_side(is_param boolean)
>     whatever()
> ...
>
> -----Original Message-----
> From: [hidden email] on behalf of Thomas Schneider
> Sent: Thu 4/21/2011 1:48 PM
> To: IBM Netrexx
> Subject: [Ibm-netrexx] Bits (0,1) vs. Bytes vs. Short vs. Int vs. LongT
>
> IBM NetRexx seems (according to my trials) a nic (?) behaviour:
>
> If I do have dd design (in my class InCompute)  a method in_right_side,
> and I would like to have a BOOLEAN parameter is_param, with a default
> value of
> FALSE (0), then, in NetRexx:
>
>       jj=o_compute.in_right_side(1)
>
> does give a FATAL error message!
>
> method in_right_side(is_param=boolean 0))
>
>      ... details in CODE Below!
>
> I would REALLY Like, when ANYBODY, may it be Rene, MFC, *or* anyone else,
> could START to FIX this (very small, but *annoying* problems, please :-)
>
> (Massa) Thomas.
>
> As attached files are NOT supported in this community,
>
> *Here is the (my) SOURCE*
> =======================================================================================
> -- trace all
> /**********************************************************************/
> /* InCompute: Generalized implementation of the COMPUTE (assignment)  */
> /*          : statement for ALL languages                             */
> /**********************************************************************/
> /*   (c) Th.Schneider, 2004-2010                                      */
> /**********************************************************************/
> /* 10.02.2010: Support for compound assignment operators added        */
> /* 20.08.2010: Code revised for Java and C++, C#                      */
> /*           : the various checks are now delayed to the Analyser     */
> /*           : in any case to speed up initial Parse, and also as     */
> /*           : the various classes are not yet available in Pass 1    */
> /*           : multiple assignments not yet supported (PL/I)          */
> /* 16.04.2011: options binary added for utmost speed                  */
> /*           : Note that NetRexx Type parsing is stll an open issue!  */
> /**********************************************************************/
>
> options binary
> package com.thsitc.rey.in -- note that InCompute is common for all languages
>
> import com.thsitc.pp.rt.
> import com.thsitc.rey.rt.
>
> class InCompute extends Object uses ReyMsg -- General version, all languages
>
> properties public static
>
> o_scan = Scan
> o_item = InItem
> o_expr = Inexpr
>
> target_nos = Rexx -- item number LIST in case of PL/I (and Rey)
> target_no= int 0
> op_code=int -- integer op_code
> source_expr_no=int 0
> debug=Options.opt_debug
> terminators=''
>
> method InCompute(x_scan=scan) public -- the constructor
>      o_scan=x_scan
>      if o_Item=Null then o_item=InItem(o_scan)
>      if o_expr=Null then o_expr=InExpr(o_scan)
>             -- o_scan.display_reserved('At InCompute') -- debug
>      return
>
> method in_COMPUTE() public ;
>      if o_scan.EOL() then ReyMsg.abort('unexpected InCompute-call at EOL!')
>
>      -- terminators=o_scan.ASN_ops o_scan.EOS
>      -- o_scan.set_phrase_terminators(terminators)
>
>      o_scan.is_LHS=1 -- we are on the left hand side of a COMPUTE
>      o_scan.is_ASSIGN=0 -- we do NOT yet know whether it ia an ASSIGNMENT
>      -- as it may be a COMMAND or method invokatiion as well !
>
>      if o_scan.verb<>  'COMPUTE' then ReyMsg.abort('InClause error,
> verb=' o_scan.verb 'is NOT Compute!')
>      /* note that 'COMPUTE' is the default verb assigned by Scan, when no
> verb is present */
>
>      target_nos=''
>
>      target_nos= in_left_side()
>      -- ReyMsg.debug('InCompute: Left side is:' Items.ThisItem(target_nos))
>
>      if o_scan.EOC() | o_scan.EOL() then return -- was a method
> invocation or a command
>      /* note that the actual EOS character is processed by InClause */
>
>      operator=o_scan.in_token()
>      op_code = o_scan.token_code
>
>      if op_code=11 then do
>         o_scan.token_code=90 -- cheat parser, = means assignment op in
> Compute
>         o_scan.token_class='Assign'
>         op_code=90
>      end
>
>      if debug then ReyMsg.debug('InCompute: Operator=' o_scan.ThisToken()
> 'op_code:' op_code)
>
>      if \o_scan.isAssignOp(operator) then do
>         ReyMsg.error('Invalid operator:' operator '(op-code:' op_code')
> for assignment')
>         o_scan.skip_statement
>         return
>      end
>
>      if o_scan.token_level>0 then do
>         ReyMsg.error('missing parenthesis/bracket before' o_scan.ThisToken())
>         o_scan.token_level=0
>      end
>
>      o_scan.out_token() -- accept operator (may be =, +=, etc now, but
> coded OP is used
>
>      source_expr_no= in_right_side()
>      if debug then ReyMsg.debug('InCompute: Right side is:'
> Items.ThisItem(source_expr_no))
>
>      if source_expr_no = 0 then ReyMsg.abort('source expression missing!')
>
>      /* Finally EMIT the code */
>      select case op_code
>         when 90 then Code.ExCode('ASN' source_expr_no target_nos)
>         when 91 then Code.ExCode('ADD' source_expr_no target_nos)
>         when 92 then Code.ExCode('SUB' source_expr_no target_nos)
>         when 93 then Code.ExCode('MUL' source_expr_no target_nos)
>         when 94 then Code.ExCode('DIV' source_expr_no target_nos)
>         when 95 then Code.ExCode('POW' source_expr_no target_nos)
>         when 96 then Code.ExCode('REM' source_expr_no target_nos) --
> REMAINDER, NOT modulo
>         when 97 then Code.ExCode('DIVI' source_expr_no target_nos) --
> INTEGER DIVISION
>         otherwise
>            ReyMsg.error('Operator:' Operator '(op_code:' op_code') not
> yet supported by InCompute!')
>      end
>
>      if  \o_scan.EOC&  \o_scan.EOL then do
>         ReyMsg.ic_error=ReyMsg.ic2
>         ReyMsg.error('premature end of statement, rest of statement ignored')
>         o_scan.skip_statement
>      end--if
>
>      -- ReyMsg.debug('end assign, operator was:' operator '(op-code:'
> op_code')')
>      return
>
> method in_left_side() public returns Rexx -- may be list of item-numbers
>
>      Global.action = 'COMPUTE'
>
>      o_scan.is_LHS=1 /* left hand side flag */
>      list= Rexx '' /* the target item number or item-number-list */
>
>      /* note that literals are NOT allowed on the left hand side */
>      select case o_scan.language
>         when 'COBOL' then list=o_item.in_item(1)
>         when 'PLI','Rey' then list=o_item.in_item_list(1) -- note that
> PLI and Rey do support multiple assignments
>         when 'Rexx','ooRexx','Regina','NetRexx' then list=o_item.in_item(1)
>         when 'Java','C','C++','C#' then list=o_item.in_item(11) -- may be
> prefixed by attributes
>         otherwise do
>            ReyMsg.error('Language:' o_scan.language 'not yet supported by
> InCompute')
>            o_scan.skip_statement()
>         end
>      end
>
>      if list=0 | list='' then abort('Parser/Program error, left side is
> empty!')
>      if debug then ReyMsg.debug('InCompute: left side(target) is:'
> Items.ThisItem(list))
>
>      if o_scan.EOC() then do -- test for End Of Clause (EOC)
>         select case o_scan.language
>
>              when 'Rey','NetRexx' then do
>                 Code.ExCode('X' list) -- EXECUTE Method(s)
>                 return 0
>              end
>              when 'COBOL','PLI' then do
>                 ReyMsg.error('Assignment Operator expected, but found:'
> o_scan.ThisToken())
>                 return 0
>              end
>           when 'Rexx','ooRexx','Regina' then do
>              Code.ExCode('CMD' list)
>              return 0
>           end
>           otherwise do
>              ReyMsg.error('Language:' o_scan.language 'not yet supported
> by InCompute')
>              o_scan.skip_statement
>              return 0
>           end
>         end
>
>      end -- note that EOS remains in input stream, as it is processed by
> InClause
>
>      return list -- return coded left side (may be an item-number or an
> item-number-list)
>
> /*********************************************************/
> /* In right side: get right side of the assignment       */
> /* the corresponding left hand side item is now passed   */
> /* as a parameter                                        */
> /*********************************************************/
>
> method in_right_side(is_param=boolean 0)  public returns int;
>      o_scan.is_LHS=0   -- set flag
>      o_scan.is_assign=1
>
>      /* note that right hand side may be any expression, even in
> declarations */
>      if is_param then ii_right=o_expr.in_expression(11) -- Parameter
> syntax expected
>      else ii_right= o_expr.in_expression(7) --any expression allowed on
> right side
>      -- nbote that in_right side is also used for Parameters
>      if ii_right=0 then ReyMsg.abort('Parser/Program error, right side is
> empty!')
>      return ii_right
>
>
>

--
Thomas Schneider (www.thsitc.com)
_______________________________________________
Ibm-netrexx mailing list
[hidden email]

[billfen]

Thomas,

Who do you expect to do the bug fixes or enhancements?  Certainly IBM isn't
interested in it, and MFC has retired.  Until RexxLA does their part of the
work to get the code open sourced, nothing will happen.  

It appears to me that there is currently no meaningful communication
between RexxLA and IBM, let alone any cooperation in getting the work done
to release the source.  
 
Perhaps Rene will comment on this - when I privately asked detailed
questions about it many months ago neither RexxLA (Rene) nor IBM (Virgil
Hein) would comment.  IBM says "Talk to Rene", and Rene refuses to talk
about it.  

As I said earlier, it sure looks like a whole lot of excuses and finger
pointing, with both sides (mostly RexxLA) unwilling to do the work.  

IMHO IBM is responsible for breaking the promise to open source, and RexxLA
is responsible for the lack of progress.  
 

Original Message:
-----------------
From: Thomas Schneider [hidden email]
Date: Thu, 21 Apr 2011 21:42:25 +0200
To: [hidden email], [hidden email]
Subject: Re: [Ibm-netrexx] Bits (0,1) vs. Bytes vs. Short vs. Int vs. Long

...

4.) What I do HATE: Quiet IBM-NetRexx Group, no enhancements, NO Bug Fixes!

Have a nice EASTER, anyway...

Massa Thomas.


--------------------------------------------------------------------
mail2web.com – What can On Demand Business Solutions do for you?
http://link.mail2web.com/Business/SharePoint



_______________________________________________
Ibm-netrexx mailing list
[hidden email]

[ThSITC]

Hello there,
as already told in this unrelated group, I'm developing *my own* NetRexx
Compiler :-)

I'm also *trying* to implement in such a way, that it will *also* accept
*classic Rexx*,
*ooRexx*, and *NetRexx* *syntax *at once.

Whil'st doing so, I'm also *trying* to implement a couple of *Language
Extensions*, to NetRexx,
as currently implemented by MFC's *reference compiler*.

I'm currently in the final stages *to document* those.

I'm using, at the minute, MFC's excellent implementation of his
*reference compiler*,
as my own one is still missing the *back-end*:

I will try to emit Java virtual machine code, NOT generate Java Code.

This has *still* to be coded, by the way.

My first steps will be:

Release ReyC *for classic Rexx*, as an upwards compatible version of my
IBM Rexx Compiler compatible Rexx2Nrx.

Whil'st Rexx2Nrx has been developed iusing IBM CLASSIC COMPILED Rexx on an
IBM Machine (CMS), years ago (I think it has been in 2002), *nowadays*,
all of my
Code is in NetRexx(1).

ReyC already does parse successfully:

-- IBM classic (compiled) Rexx (including %INCLUDE's, etc)
-- Object Rexx (vs. 1)
-- Most of REGINA

*in one Parser* :-)

Thus, my implementation should and will allow a *mixed dialect mode*.

The intent of this, my whole, effort is:

*Finally* Rey: *a new Language* (Rexx for Java).

This does and will give me the freedom to *extend* the language when I
do find a need
to do so.

Frankly speaking: I do like *BOOTS*-*trapping+

I also do feel, that a second implementation of the NetRexx Language,
which is the best
designed language I've ever seen, might be worthwhile.... ;-)

I simply did introduce the ACRONYM REY (Rexx for Java, sorry for the
mis-sprelling
of the last letter <grin>) to have the ability to do what I what to do :-)

Please go ahead and do subscribe my Project 'ReyC' there at
www.kenai.com :-)

ReyC is open sourced, with the help of David Requena, author of the well
known
NetRexxDE, on 1. Mai (2011).

It will NOT yet compile ooRexx and/or NetRexx, but will replace the ancient
Rexx2Nrx.

You will find all the other details on www.thsitc.com *very soon*

Greetings from Vienna.

Thomas.
=================================================================

Am 22.04.2011 21:39, schrieb [hidden email]:

> Thomas,
>
> Who do you expect to do the bug fixes or enhancements?  Certainly IBM isn't
> interested in it, and MFC has retired.  Until RexxLA does their part of the
> work to get the code open sourced, nothing will happen.
>
> It appears to me that there is currently no meaningful communication
> between RexxLA and IBM, let alone any cooperation in getting the work done
> to release the source.
>
> Perhaps Rene will comment on this - when I privately asked detailed
> questions about it many months ago neither RexxLA (Rene) nor IBM (Virgil
> Hein) would comment.  IBM says "Talk to Rene", and Rene refuses to talk
> about it.
>
> As I said earlier, it sure looks like a whole lot of excuses and finger
> pointing, with both sides (mostly RexxLA) unwilling to do the work.
>
> IMHO IBM is responsible for breaking the promise to open source, and RexxLA
> is responsible for the lack of progress.
>
>
> Original Message:
> -----------------
> From: Thomas Schneider [hidden email]
> Date: Thu, 21 Apr 2011 21:42:25 +0200
> To: [hidden email], [hidden email]
> Subject: Re: [Ibm-netrexx] Bits (0,1) vs. Bytes vs. Short vs. Int vs. Long
>
> ...
>
> 4.) What I do HATE: Quiet IBM-NetRexx Group, no enhancements, NO Bug Fixes!
>
> Have a nice EASTER, anyway...
>
> Massa Thomas.
>
>
> --------------------------------------------------------------------
> mail2web.com – What can On Demand Business Solutions do for you?
> http://link.mail2web.com/Business/SharePoint
>
>
>
> _______________________________________________
> Ibm-netrexx mailing list
> [hidden email]
>
>

--
Thomas Schneider (www.thsitc.com)
_______________________________________________
Ibm-netrexx mailing list
[hidden email]

[christel.u.w.pachl christel.u.w.pachl]

Thomas,

Having seen (and not always understood) your thousands of postings
I'd like to contribute my 2 Cents this time:

David: "Stop announcing until you're really ready for a release. That will cut on the
reproof you're getting because of restless adverising."

DO THIS!

You: "I'm using, at the minute, MFC's excellent implementation of his
*reference compiler*,  as my own one is still missing the *back-end*:"

If I understand this correctly, your first Release will be a Parser with improved
error diagnosis for Netrexx-language with your extensions.
The output of this Parser will be ???.

What exactly of MFC's implementation are you using?

Season's Greetings!

Walter  

---- Thomas Schneider <[hidden email]> schrieb:
> Hello there,
_______________________________________________
Ibm-netrexx mailing list
[hidden email]

[ThSITC]

Hi Walter & all,
    Output of the Parser is PP's internal CODE and DECL, whch is common
for classic Rexx,
ooRexx, NetRexx, PL/I, COBOL; and Rey, and, in near future (autumn 2011)
NATURAL.
    I'm currently generating NetRexx (for all languages).
    Which is a bit meaningless, when *plain NetRexx* (without my
extensions)  is the source language.
Happy Easter,
Thomas.
=====================================
Am 23.04.2011 08:11, schrieb Walter Pachl:

> Thomas,
>
> Having seen (and not always understood) your thousands of postings
> I'd like to contribute my 2 Cents this time:
>
> David: "Stop announcing until you're really ready for a release. That will cut on the
> reproof you're getting because of restless adverising."
>
> DO THIS!
>
> You: "I'm using, at the minute, MFC's excellent implementation of his
> *reference compiler*,  as my own one is still missing the *back-end*:"
>
> If I understand this correctly, your first Release will be a Parser with improved
> error diagnosis for Netrexx-language with your extensions.
> The output of this Parser will be ???.
>
> What exactly of MFC's implementation are you using?
>
> Season's Greetings!
>
> Walter
>
> ---- Thomas Schneider<[hidden email]>  schrieb:
>> Hello there,

--
Thomas Schneider (www.thsitc.com)
_______________________________________________
Ibm-netrexx mailing list
[hidden email]