/plugins/NetRexxScript/tags/0.1.1/atOnce/netrexxAtOnce03.html

# · HTML · 252 lines · 240 code · 12 blank · 0 comment · 0 complexity · ac8c09371be066899ef80903d72e67d3 MD5 · raw file 

    

  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    2. 

  2. <html><head><title>NetRexx at Once</title></head>

    3. 

  3. <body style="color: rgb(0, 0, 0); background-color: rgb(204, 204, 204);" alink="#ff0000" link="#0000ff" vlink="#800080">

    4. 

  4. 

    5. 

  5. <a name="TYPES"></a>

    6. 

  6. <center>

    7. 

  7. <h1><font color="#ff0000">NetRexx at Once</font></h1>

    8. 

  8. <h2><font color="#ff0000">Quick Guide for Java Developers</font></h2>

    9. 

  9. </center>

    10. 

  10. 

    11. 

  11. <hr><a href="netrexxAtOnce.html">[Index]</a> <a href="netrexxAtOnce02.html">[Previous Chapter]</a> <a href="netrexxAtOnce04.html">[Next Chapter]</a>

    12. 

  12. 

    13. 

  13. <h2><font color="#ff0000">3. Types</font></h2>

    14. 

  14. <p>To work with NetRexx you need to use only one type: the REXX type.

    15. 

  15. This is a powerful String class that can be used as a usual String, a

    16. 

  16. floating number, a whole number and so on. However you can still use

    17. 

  17. basic types (e.g. int, double etc.) for better performance. A useful

    18. 

  18. feature is the ability to set the precision of numbers.

    19. 

  19. </p><p><a name="TYPE REXX"></a>

    20. 

  20. </p><h3><font color="#ff0000">3.1 NetRexx Strings</font></h3>

    21. 

  21. <p>In the following two paragraphs we'll see the operators that work with the REXX type and the use of the PARSE instruction.

    22. 

  22. 

    23. 

  23. </p><p><a name="TYPE REXX OP"></a>

    24. 

  24. </p><h4><font color="#ff0000">3.1.1 Operators</font></h4>

    25. 

  25. <p>These are the operators used in Java compared to the ones of NetRexx:

    26. 

  26. </p><p><table border="1" cellpadding="10"><tbody><tr><td bgcolor="#ffffcc">

    27. 

  27. <b>Java</b></td><td bgcolor="#ccffff"><b>NetRexx</b></td></tr>

    28. 

  28. <tr><td bgcolor="#ffffcc">

    29. 

  29. <pre><b>Unary on numbers</b>

    30. 

  30. -  <i>negation</i>

    31. 

  31. ~  <i>bitwise complement</i>

    32. 

  32. ++ <i>increment</i>

    33. 

  33. -- <i>decrement</i>

    34. 

  34. </pre>

    35. 

  35. </td><td bgcolor="#ccffff">

    36. 

  36. <pre><b>Unary on numbers</b>

    37. 

  37. - <i>negation</i>

    38. 

  38. .

    39. 

  39. .

    40. 

  40. .

    41. 

  41. </pre>

    42. 

  42. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    43. 

  43. <ul>

    44. 

  44. <li>No operators working on <b>bitfields</b>.

    45. 

  45. </li><li>No <b>increment</b> or <b>decrement</b> operators.

    46. 

  46. </li></ul></td></tr>

    47. 

  47. <tr><td bgcolor="#ffffcc">

    48. 

  48. <pre><b>Binary on numbers</b>

    49. 

  49. +   <i>addition</i>

    50. 

  50. -   <i>subtraction</i>

    51. 

  51. *   <i>multiplication</i>

    52. 

  52. /   <i>division</i>

    53. 

  53. %   <i>modulus</i>

    54. 

  54. &amp;   <i>bitwise and</i>

    55. 

  55. |   <i>bitwise or</i>

    56. 

  56. ^   <i>bitwise xor</i>

    57. 

  57. &lt;&lt;  <i>left shift</i>

    58. 

  58. &gt;&gt;  <i>right shift (sign propagating)</i>

    59. 

  59. &gt;&gt;&gt; <i>right shift (zero-fill)</i>

    60. 

  60. op= <i>operator with assignment</i>

    61. 

  61. </pre>

    62. 

  62. </td><td bgcolor="#ccffff">

    63. 

  63. <pre><b>Binary on numbers</b>

    64. 

  64. +   <i>addition</i>

    65. 

  65. -   <i>subtraction</i>

    66. 

  66. *   <i>multiplication</i>

    67. 

  67. /   <i>division</i><br>//  <i>remainder</i><br>%   <i>integer part of division</i><i></i>

    68. 

  68. **  <i>power</i>

    69. 

  69. .

    70. 

  70. .

    71. 

  71. .

    72. 

  72. .

    73. 

  73. .

    74. 

  74. .

    75. 

  75. </pre>

    76. 

  76. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    77. 

  77. <ul>

    78. 

  78. <li>No operators working on <b>bitfields</b>.

    79. 

  79. </li><li>Modulus replaced by <b>integer divide</b> and <b>reminder</b>.

    80. 

  80. </li><li>Added <b>power</b> operator.

    81. 

  81. </li><li>No operators with <b>assignment implied</b>.

    82. 

  82. </li></ul></td></tr>

    83. 

  83. <tr><td bgcolor="#ffffcc">

    84. 

  84. <pre><b>Relationals</b>

    85. 

  85. &lt;   <i>less than</i>

    86. 

  86. &gt;   <i>greater than</i>

    87. 

  87. &lt;=  <i>less or equal</i>

    88. 

  88. &gt;=  <i>greater or equal</i>

    89. 

  89. ==  <i>equal</i>

    90. 

  90. !=  <i>not equal</i>

    91. 

  91. .

    92. 

  92. .

    93. 

  93. .

    94. 

  94. .

    95. 

  95. .

    96. 

  96. .

    97. 

  97. </pre>

    98. 

  98. </td><td bgcolor="#ccffff">

    99. 

  99. <pre><b>Relationals</b>

    100. 

  100. &lt;        <i>less than</i>

    101. 

  101. &gt;        <i>greater than</i>

    102. 

  102. &lt;= \&gt;    <i>less or equal</i>

    103. 

  103. &gt;= \&lt;    <i>greater or equal</i>

    104. 

  104. =        <i>equal</i>

    105. 

  105. \= &gt;&lt; &lt;&gt; <i>not equal</i>

    106. 

  106. ==       <i>strictly equal</i>

    107. 

  107. \==      <i>strictly not equal</i>

    108. 

  108. &lt;&lt;       <i>strictly less than</i>

    109. 

  109. &gt;&gt;       <i>strictly greater than</i>

    110. 

  110. &lt;&lt;= \&gt;&gt;  <i>strictly less than or equal to</i>

    111. 

  111. &gt;&gt;= \&gt;&gt;  <i>strictly greater than or equal to</i>

    112. 

  112. </pre>

    113. 

  113. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    114. 

  114. <ul>

    115. 

  115. <li><b>\</b> used instead of <b>!</b>

    116. 

  116. </li><li><b>several combination</b> for the same operator

    117. 

  117. </li><li>Added <b>strict comparisons</b>, useful to test if two objects are the same.<br>For example "1.2"="1.20" is true, while "1.2"=="1.20" is false<br>and "Leo"="leo" is true, while "Leo"=="leo" is false.

    118. 

  118. </li></ul></td></tr>

    119. 

  119. <tr><td bgcolor="#ffffcc">

    120. 

  120. <pre><b>Logical</b>

    121. 

  121. &amp;&amp;     <i>and</i>

    122. 

  122. ||     <i>or</i>

    123. 

  123. !      <i>not</i>

    124. 

  124. .

    125. 

  125. true   <i>true value</i>

    126. 

  126. false  <i>false value</i>

    127. 

  127. </pre>

    128. 

  128. </td><td bgcolor="#ccffff">

    129. 

  129. <pre><b>Logical</b>

    130. 

  130. &amp;   <i>and</i>

    131. 

  131. |   <i>or</i>

    132. 

  132. \   <i>not</i>

    133. 

  133. &amp;&amp;  <i>xor</i>

    134. 

  134. 1   <i>true value</i>

    135. 

  135. 0   <i>false value</i>

    136. 

  136. </pre>

    137. 

  137. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    138. 

  138. <ul>

    139. 

  139. <li>These operators work on logical values: <b>0</b> stands for false and <b>1</b> for true.

    140. 

  140. </li></ul></td></tr>

    141. 

  141. <tr><td bgcolor="#ffffcc">

    142. 

  142. <pre><b>String operators</b>

    143. 

  143. +  <i>concatenation</i>

    144. 

  144. .

    145. 

  145. </pre>

    146. 

  146. </td><td bgcolor="#ccffff">

    147. 

  147. <pre><b>String operators</b>

    148. 

  148. || <i>or</i> abuttal  <i>concatenation</i>

    149. 

  149. blanck           <i>   "   with blanck</i>

    150. 

  150. </pre>

    151. 

  151. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    152. 

  152. <ul>

    153. 

  153. <li><b>All</b> the operators in the above sections work on <b>REXX Strings</b>:<br>even the mathematical operators, if the string represents a number.

    154. 

  154. </li><li>Concatenation of Strings is often <b>implied</b>.<br>For example:<br>'Hi!' 'All.' and 'Hi!' ''All" both mean 'Hi! All.'<br>Finally a||b is 'Hi! All.' if a='Hi! ' and b='All.'

    155. 

  155. </li></ul></td></tr>

    156. 

  156. <tr><td bgcolor="#ffffcc">

    157. 

  157. <pre><b>Casting and testing</b>

    158. 

  158. (<i>class</i>)<i>object</i>

    159. 

  159. <i>object</i> instanceof <i>class</i>

    160. 

  160. </pre>

    161. 

  161. </td><td bgcolor="#ccffff">

    162. 

  162. <pre><b>Casting and testing</b>

    163. 

  163. <i>class</i> <i>object</i>

    164. 

  164. <i>object</i>&lt;=<i>class</i> <i>or</i> <i>class</i>&gt;=<i>object</i>

    165. 

  165. </pre>

    166. 

  166. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    167. 

  167. <ul>

    168. 

  168. <li><b>No parentheses</b> needed to cast an <i>object</i>.

    169. 

  169. </li><li><b>&lt;=</b> or <b>=&gt;</b> used to test if an <i>object</i> is of type <i>class</i>.

    170. 

  170. </li></ul></td></tr>

    171. 

  171. </tbody></table>

    172. 

  172. 

    173. 

  173. </p><p><font color="#ff0000">PRECEDENCE</font> The operators are now listed in order of precedence:

    174. 

  174. </p><p><table border="1" cellpadding="10"><tbody><tr><td bgcolor="#ffffcc">

    175. 

  175. <b>Java</b><br>

    176. 

  176. <pre>. [] ()<br>++ -- ! ~ instanceof<br>* / %<br>+ -<br>&lt;&lt; &gt;&gt; &gt;&gt;&gt;<br>&lt; &gt; &lt;= &gt;=<br>== !=<br>&amp;<br>^<br>|<br>&amp;&amp;<br>||<br>?:<br>= op=<br>,<br></pre>

    177. 

  177. </td><td bgcolor="#ccffff">

    178. 

  178. <b>NetRexx</b><br>

    179. 

  179. <pre>. [] ()<br>+  -  \ (<i>prefixes</i>)<br><br>**<br>* / % //<br>+  -<br><br>blank || abuttal (<i>concatenation</i>)<br><br>=  ==  &gt;  &lt;  &lt;= &gt;=  &lt;&lt;  \&gt;&gt; ...<br><br>&amp;<br>|  &amp;&amp;<br><br>= (<i>assignment</i>)<br></pre>

    180. 

  180. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    181. 

  181. <b>notes</b><br>

    182. 

  182. <ul>

    183. 

  183. <li><b>**</b> has less precedence than prefixed <b>-</b>, so -2**2 = 4.

    184. 

  184. </li></ul>

    185. 

  185. </td></tr>

    186. 

  186. </tbody></table>

    187. 

  187. 

    188. 

  188. </p><p><a name="TYPE REXX PARSE"></a>

    189. 

  189. </p><h4><font color="#ff0000">3.1.2 PARSE Instruction</font></h4>

    190. 

  190. <p>Parsing is a powerful mechanism that extracts strings from another

    191. 

  191. string using pattern matching or other rules according to a template.

    192. 

  192. You can parse strings with the <b>PARSE</b> instruction.<br>For

    193. 

  193. example, imagine that an application must print on the screen the five

    194. 

  194. strings passed in the command line as an unique string with commas as

    195. 

  195. separators. Compare the two chuncks of code:

    196. 

  196. </p><p><table border="1" cellpadding="10"><tbody><tr><td bgcolor="#ffffcc">

    197. 

  197. <b>Java</b><br>

    198. 

  198. <pre>/* This is Split.java */<br>public class split {<br>  public static void main(String[] arg) {<br>    String retStr = arg[0];<br>    String[] string = new String[5];<br>    int idx = -1;<br>    for(int ct = 0; ct &lt; 4; ct++) {<br>      idx++;<br>      string[ct] =<br>        retStr.substring(<br>          idx,<br>          idx = retStr.indexOf(",",idx)<br>        )<br>      ;<br>    }<br>    string[4] = retStr.substring(idx+1);<br>    for(int ct = 0; ct &lt; 5; ct++) {<br>      System.out.println(string[ct]);<br>    }<br>  }<br>}<br></pre>

    199. 

  199. </td><td bgcolor="#ccffff">

    200. 

  200. <b>NetRexx</b><br>

    201. 

  201. <pre>/* This is split.nrx */<br>parse arg a','b','c','d','e<br>say a'\n'b'\n'c'\n'd'\n'e<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br></pre>

    202. 

  202. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    203. 

  203. <b>notes</b><br>

    204. 

  204. <ul>

    205. 

  205. <li>The <b>PARSE</b> instruction accepts a string and a template to split it in parts.<br>This instruction avoids a lot of programming for string management.

    206. 

  206. </li><li>There are several ways to define templates (e.g. you can use<br><b>literal</b> patterns, <b>positional</b> patterns and <b>variable</b> patterns).

    207. 

  207. </li></ul>

    208. 

  208. </td></tr>

    209. 

  209. </tbody></table>

    210. 

  210. 

    211. 

  211. </p><p><a name="TYPE IDX"></a>

    212. 

  212. </p><h3><font color="#ff0000">3.2 Indexed Strings and Arrays</font></h3>

    213. 

  213. <p>In NetRexx you can define arrays as in Java. The difference is in the syntax:

    214. 

  214. 

    215. 

  215. </p><p><table border="1" cellpadding="10"><tbody><tr><td bgcolor="#ffffcc">

    216. 

  216. <b>Java</b><br>

    217. 

  217. <pre>// Declaring a String Array<br>String[] aString;<br>// Three String Array<br>aString = new String[3];<br>// Initializing<br>String[] aString = {"s1","s2","s3"};<br>// A two dimensinonal Array<br>String[][] bString;<br>// Initializing<br>String[][] bString =<br>  {{"s1","s2"},{"s3","s4"}}<br>;<br></pre>

    218. 

  218. </td><td bgcolor="#ccffff">

    219. 

  219. <b>NetRexx</b><br>

    220. 

  220. <pre>-- Declaring a String Array<br>aString=String[]<br>-- Three String Array<br>aString=String[3]<br>-- Initializing<br>aString=['s1','s2','s3']<br>-- A two dimensinonal Array<br>bString=String[,]<br>-- Initializing<br>bString=[['s1','s2'],['s3','s4']]<br>--<br>--<br></pre>

    221. 

  221. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    222. 

  222. <b>notes</b><br>

    223. 

  223. <ul>

    224. 

  224. <li>No <b>new</b> keyword required to create arrays.

    225. 

  225. </li><li>The type of the array with initializers is derived from the <b>first</b> element.

    226. 

  226. </li></ul>

    227. 

  227. </td></tr>

    228. 

  228. </tbody></table>

    229. 

  229. 

    230. 

  230. </p><p>A very powerful feature of NetRexx are <b>Indexed Strings</b>.

    231. 

  231. Every REXX string may have one or more sub-values that can be retrieved

    232. 

  232. giving a string index. This sub-values are treated as REXX strings and

    233. 

  233. they may have sub-values, too.<br>For example, consider a small dictionary from Italian to English. With Java you can use the <b>java.util.Hashtable</b> class:

    234. 

  234. 

    235. 

  235. </p><p><table border="1" cellpadding="10"><tbody><tr><td bgcolor="#ffffcc">

    236. 

  236. <b>Java</b><br>

    237. 

  237. <pre>/* This is Translate.java */<br>import java.io.*;<br>import java.util.Hashtable;<br>public class Translate {<br>  public static void main(String[] arg) {<br>    Hashtable dict = new Hashtable();<br>    dict.put("ciao","hi");<br>    dict.put("gatto","cat");<br>    dict.put("luna","moon");<br>// and more...<br>    BufferedReader r =<br>      new BufferedReader(<br>        new InputStreamReader(System.in)<br>      )<br>    ;<br>    String again;<br>    try {<br>    do {<br>      System.out.print("Translation of ");<br>      String trans = r.readLine();<br>      if(<br>        (trans = (String)dict.get(trans))<br>        == null<br>      )<br>        trans = "unknown"<br>      ;<br>      System.out.println("is '"+trans+"'");<br>      System.out.print("Again? [y/n] ");<br>      again = r.readLine();<br>    } while(again.equals("y"));<br>    } catch(IOException e) {<br>      e.printStackTrace();<br>    }<br>  }<br>}<br></pre>

    238. 

  238. </td><td bgcolor="#ccffff">

    239. 

  239. <b>NetRexx</b><br>

    240. 

  240. <pre>/* This is Translate.nrx */<br>dict='unknown'<br>dict['ciao']='hi'<br>dict['gatto']='cat'<br>dict['luna']='moon'<br>-- and more...<br>again=String<br>loop until again\='y'<br>  say'Translation of '<br>  trans=ask<br>  say'is' dict[trans]<br>  say'Again? [y/n] '<br>  again=ask<br>end<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br>--<br></pre>

    241. 

  241. </td></tr><tr><td colspan="2" bgcolor="#ffccff">

    242. 

  242. <b>notes</b><br>

    243. 

  243. <ul>

    244. 

  244. <li>A REXX variable <b>must have a value</b> assigned before it can be indexed.

    245. 

  245. </li><li><b>Multiple indexing</b> is possible, i.e. every sub-value may have sub-values attached.</li><li>iv1.copyindexed(iv2) returns a merge (union) of two idexed variables iv1 and iv2</li></ul>

    246. 

  246. </td></tr>

    247. 

  247. </tbody></table>

    248. 

  248. 

    249. 

  249. </p><p><a href="netrexxAtOnce.html">[Index]</a> <a href="netrexxAtOnce02.html">[Previous Chapter]</a> <a href="netrexxAtOnce04.html">[Next Chapter]</a>

    250. 

  250. 

    251. 

  251. </p><hr><br>

    252. 

  252. </body></html>
    253.