Changeset 4048


Ignore:
Timestamp:
Dec 17, 2008, 8:17:33 PM (12 years ago)
Author:
yura
Message:
  • $error messages refactoring.
Location:
to-imperative/trunk/java
Files:
2 deleted
18 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/java/java/org/refal/plus/RefalException.java

    r4047 r4048  
    1212    }
    1313
    14     public RefalException (String lib, String func, String error) {
    15         // FIXME: if in compatibility mode then shouldn't throw lib.
    16         expr = Expr.getConcatenator(3).toRight(lib).toRight(func).toRight(error).yield();
     14    public RefalException (String module, String func, String error) {
     15        expr = Expr.getConcatenator(2).toRight(module + "." + func).toRight(error).yield();
     16    }
     17
     18    public RefalException (String func, String error) {
     19        expr = Expr.getConcatenator(2).toRight(func).toRight(error).yield();
    1720    }
    1821
     
    2326    @Override
    2427    public String toString () {
    25         return expr.toChars();
     28        return expr.toString();
    2629    }
    2730}
  • to-imperative/trunk/java/java/refal/plus/Access.java

    r3745 r4048  
    2323            return true;
    2424        } catch (ValueOutOfBoundsException e) {
    25             throw new RefalException("Access", "L", "Invalid argument");
     25            throw new RefalException("refal.plus.Access.L", "Invalid argument");
    2626        } catch (ClassCastException e) {
    27             throw new RefalException("Access", "L", "Invalid argument");
     27            throw new RefalException("refal.plus.Access.L", "Invalid argument");
    2828        }
    2929    }
     
    3838            return true;
    3939        } catch (ValueOutOfBoundsException e) {
    40             throw new RefalException("Access", "R", "Invalid argument");
     40            throw new RefalException("refal.plus.Access.R", "Invalid argument");
    4141        } catch (ClassCastException e) {
    42             throw new RefalException("Access", "R", "Invalid argument");
     42            throw new RefalException("refal.plus.Access.R", "Invalid argument");
    4343        }
    4444    }
     
    5454            return true;
    5555        } catch (ValueOutOfBoundsException e) {
    56             throw new RefalException("Access", "Left", "Invalid argument");
     56            throw new RefalException("refal.plus.Access.Left", "Invalid argument");
    5757        } catch (ClassCastException e) {
    58             throw new RefalException("Access", "Left", "Invalid argument");
     58            throw new RefalException("refal.plus.Access.Left", "Invalid argument");
    5959        }
    6060    }
     
    7070            return true;
    7171        } catch (ValueOutOfBoundsException e) {
    72             throw new RefalException("Access", "Right", "Invalid argument");
     72            throw new RefalException("refal.plus.Access.Right", "Invalid argument");
    7373        } catch (ClassCastException e) {
    74             throw new RefalException("Access", "Right", "Invalid argument");
     74            throw new RefalException("refal.plus.Access.Right", "Invalid argument");
    7575        }
    7676    }
     
    8686            return true;
    8787        } catch (ValueOutOfBoundsException e) {
    88             throw new RefalException("Access", "Middle", "Invalid argument");
     88            throw new RefalException("refal.plus.Access.Middle", "Invalid argument");
    8989        } catch (ClassCastException e) {
    90             throw new RefalException("Access", "Middle", "Invalid argument");
     90            throw new RefalException("refal.plus.Access.Middle", "Invalid argument");
    9191        }
    9292    }
  • to-imperative/trunk/java/java/refal/plus/Apply.java

    r3746 r4048  
    2020            return ((Func) Symbol.getObject(func)).eval(arg, res);
    2121        } catch (ClassCastException e) {
    22             throw new RefalException("Apply", "Apply", "Invalid argument");
     22            throw new RefalException("refal.plus.Apply.Apply", "Invalid argument");
    2323        }
    2424    }
  • to-imperative/trunk/java/java/refal/plus/Arithm.java

    r4040 r4048  
    2020            res.assign(Util.getBigInteger(int1).add(Util.getBigInteger(int2)));
    2121        } catch (ClassCastException e) {
    22             throw new RefalException("Arithm", "Add", "Invalid argument");
     22            throw new RefalException("refal.plus.Arithm.Add", "Invalid argument");
    2323        }
    2424    }
     
    2929            res.assign(Util.getBigInteger(int1).subtract(Util.getBigInteger(int2)));
    3030        } catch (ClassCastException e) {
    31             throw new RefalException("Arithm", "Sub", "Invalid argument");
     31            throw new RefalException("refal.plus.Arithm.Sub", "Invalid argument");
    3232        }
    3333    }
     
    3838            res.assign(Util.getBigInteger(int1).multiply(Util.getBigInteger(int2)));
    3939        } catch (ClassCastException e) {
    40             throw new RefalException("Arithm", "Mult", "Invalid argument");
     40            throw new RefalException("refal.plus.Arithm.Mult", "Invalid argument");
    4141        }
    4242    }
     
    4747            quo.assign(Util.getBigInteger(int1).divide(Util.getBigInteger(int2)));
    4848        } catch (ArithmeticException e) {
    49             throw new RefalException("Arithm", "Div", "Divide by zero");
     49            throw new RefalException("refal.plus.Arithm.Div", "Divide by zero");
    5050        } catch (ClassCastException e) {
    51             throw new RefalException("Arithm", "Div", "Invalid argument");
     51            throw new RefalException("refal.plus.Arithm.Div", "Invalid argument");
    5252        }
    5353    }
     
    5858            rem.assign(Util.getBigInteger(int1).remainder(Util.getBigInteger(int2)));
    5959        } catch (ArithmeticException e) {
    60             throw new RefalException("Arithm", "Rem", "Divide by zero");
     60            throw new RefalException("refal.plus.Arithm.Rem", "Divide by zero");
    6161        } catch (ClassCastException e) {
    62             throw new RefalException("Arithm", "Rem", "Invalid argument");
     62            throw new RefalException("refal.plus.Arithm.Rem", "Invalid argument");
    6363        }
    6464    }
     
    7171            rem.assign(a[1]);
    7272        } catch (ArithmeticException e) {
    73             throw new RefalException("Arithm", "DivRem", "Divide by zero");
     73            throw new RefalException("refal.plus.Arithm.DivRem", "Divide by zero");
    7474        } catch (ClassCastException e) {
    75             throw new RefalException("Arithm", "DivRem", "Invalid argument");
     75            throw new RefalException("refal.plus.Arithm.DivRem", "Invalid argument");
    7676        }
    7777    }
     
    8282            BigInteger d = Util.getBigInteger(int1).gcd(Util.getBigInteger(int2));
    8383            if (d.equals(BigInteger.ZERO))
    84                 throw new RefalException("Arithm", "Gcd", "Zero arguments");
     84                throw new RefalException("refal.plus.Arithm.Gcd", "Zero arguments");
    8585            gcd.assign(d);
    8686        } catch (ClassCastException e) {
    87             throw new RefalException("Arithm", "Gcd", "Invalid argument");
     87            throw new RefalException("refal.plus.Arithm.Gcd", "Invalid argument");
    8888        }
    8989    }
     
    9494            res.assign(Util.getBigInteger(int1).abs());
    9595        } catch (ClassCastException e) {
    96             throw new RefalException("Arithm", "Abs", "Invalid argument");
     96            throw new RefalException("refal.plus.Arithm.Abs", "Invalid argument");
    9797        }
    9898    }
     
    103103            max.assign(Util.getBigInteger(int1).max(Util.getBigInteger(int2)));
    104104        } catch (ClassCastException e) {
    105             throw new RefalException("Arithm", "Max", "Invalid argument");
     105            throw new RefalException("refal.plus.Arithm.Max", "Invalid argument");
    106106        }
    107107    }
     
    112112            min.assign(Util.getBigInteger(int1).min(Util.getBigInteger(int2)));
    113113        } catch (ClassCastException e) {
    114             throw new RefalException("Arithm", "Min", "Invalid argument");
     114            throw new RefalException("refal.plus.Arithm.Min", "Invalid argument");
    115115        }
    116116    }
  • to-imperative/trunk/java/java/refal/plus/Bit.java

    r3746 r4048  
    2121            res.assign(Util.getBigInteger(int1).and(Util.getBigInteger(int2)));
    2222        } catch (ClassCastException _) {
    23             throw new RefalException("Bit", "BitAnd", "Invalid argument");
     23            throw new RefalException("refal.plus.Bit.BitAnd", "Invalid argument");
    2424        }
    2525    }
     
    3030            res.assign(Util.getBigInteger(int1).or(Util.getBigInteger(int2)));
    3131        } catch (ClassCastException _) {
    32             throw new RefalException("Bit", "BitOr", "Invalid argument");
     32            throw new RefalException("refal.plus.Bit.BitOr", "Invalid argument");
    3333        }
    3434    }
     
    3939            res.assign(Util.getBigInteger(int1).xor(Util.getBigInteger(int2)));
    4040        } catch (ClassCastException _) {
    41             throw new RefalException("Bit", "BitXor", "Invalid argument");
     41            throw new RefalException("refal.plus.Bit.BitXor", "Invalid argument");
    4242        }
    4343    }
     
    4848            res.assign(Util.getBigInteger(int1).not());
    4949        } catch (ClassCastException _) {
    50             throw new RefalException("Bit", "BitNot", "Invalid argument");
     50            throw new RefalException("refal.plus.Bit.BitNot", "Invalid argument");
    5151        }
    5252    }
     
    5757            res.assign(Util.getBigInteger(int1).shiftLeft(Util.intValue(shift)));
    5858        } catch (ValueOutOfBoundsException _) {
    59             throw new RefalException("Bit", "BitLeft", "Invalid argument");
     59            throw new RefalException("refal.plus.Bit.BitLeft", "Invalid argument");
    6060        } catch (ClassCastException _) {
    61             throw new RefalException("Bit", "BitLeft", "Invalid argument");
     61            throw new RefalException("refal.plus.Bit.BitLeft", "Invalid argument");
    6262        }
    6363    }
     
    6868            res.assign(Util.getBigInteger(int1).shiftRight(Util.intValue(shift)));
    6969        } catch (ValueOutOfBoundsException _) {
    70             throw new RefalException("Bit", "BitRight", "Invalid argument");
     70            throw new RefalException("refal.plus.Bit.BitRight", "Invalid argument");
    7171        } catch (ClassCastException _) {
    72             throw new RefalException("Bit", "BitRight", "Invalid argument");
     72            throw new RefalException("refal.plus.Bit.BitRight", "Invalid argument");
    7373        }
    7474    }
     
    7979            return Util.getBigInteger(int1).testBit(Util.uintValue(pos));
    8080        } catch (ValueOutOfBoundsException _) {
    81             throw new RefalException("Bit", "BitLeft", "Invalid argument");
     81            throw new RefalException("refal.plus.Bit.BitLeft", "Invalid argument");
    8282        } catch (ClassCastException _) {
    83             throw new RefalException("Bit", "BitTest", "Invalid argument");
     83            throw new RefalException("refal.plus.Bit.BitTest", "Invalid argument");
    8484        }
    8585    }
     
    9090            res.assign(Util.getBigInteger(int1).setBit(Util.uintValue(index)));
    9191        } catch (ValueOutOfBoundsException _) {
    92             throw new RefalException("Bit", "BitSet", "Invalid argument");
     92            throw new RefalException("refal.plus.Bit.BitSet", "Invalid argument");
    9393        } catch (ClassCastException _) {
    94             throw new RefalException("Bit", "BitSet", "Invalid argument");
     94            throw new RefalException("refal.plus.Bit.BitSet", "Invalid argument");
    9595        }
    9696    }
     
    101101            res.assign(Util.getBigInteger(int1).clearBit(Util.uintValue(index)));
    102102        } catch (ValueOutOfBoundsException _) {
    103             throw new RefalException("Bit", "BitClear", "Invalid argument");
     103            throw new RefalException("refal.plus.Bit.BitClear", "Invalid argument");
    104104        } catch (ClassCastException _) {
    105             throw new RefalException("Bit", "BitClear", "Invalid argument");
     105            throw new RefalException("refal.plus.Bit.BitClear", "Invalid argument");
    106106        }
    107107    }
     
    112112            length.assign(BigInteger.valueOf(Util.getBigInteger(int1).bitLength()));
    113113        } catch (ClassCastException _) {
    114             throw new RefalException("Bit", "BitLength", "Invalid argument");
     114            throw new RefalException("refal.plus.Bit.BitLength", "Invalid argument");
    115115        }
    116116    }
     
    122122            hex.assign((i.compareTo(BigInteger.ZERO) >= 0 ? "0x" + i.toString(16) : "-0x" + i.abs().toString(16)));
    123123        } catch (ClassCastException _) {
    124             throw new RefalException("Bit", "BitPrint", "Invalid argument");
     124            throw new RefalException("refal.plus.Bit.BitPrint", "Invalid argument");
    125125        }
    126126    }
  • to-imperative/trunk/java/java/refal/plus/Box.java

    r3725 r4048  
    3030            expr.assign(getBox(box).expr);
    3131        } catch (ClassCastException _) {
    32             throw new RefalException("Box", "Get", "Invalid argument");
     32            throw new RefalException("refal.plus.Box.Get", "Invalid argument");
    3333        }
    3434    }
     
    4040            getBox(box).expr = expr;
    4141        } catch (ClassCastException _) {
    42             throw new RefalException("Box", "Store", "Invalid argument");
     42            throw new RefalException("refal.plus.Box.Store", "Invalid argument");
    4343        }
    4444    }
  • to-imperative/trunk/java/java/refal/plus/Dir.java

    r4025 r4048  
    1616    private int pointer;
    1717
    18     public Dir (java.lang.String name) throws RefalException {
     18    private Dir (java.lang.String name) throws RefalException {
    1919        files = (new File(name)).list();
    2020        if (files == null)
    21             throw new RefalException("Dir", "OpenDir", name + " is not a directory");
     21            throw new RefalException("refal.plus.Dir.OpenDir", name + " is not a directory");
    2222        pointer = 0;
    2323    }
     
    4747            return false;
    4848        } catch (ClassCastException _) {
    49             throw new RefalException("Dir", "ReadDir", "Invalid argument");
     49            throw new RefalException("refal.plus.Dir.ReadDir", "Invalid argument");
    5050        }
    5151    }
     
    5656            ((Dir) Util.getTerm(dir)).files = null;
    5757        } catch (ClassCastException _) {
    58             throw new RefalException("Dir", "CloseDir", "Invalid argument");
     58            throw new RefalException("refal.plus.Dir.CloseDir", "Invalid argument");
    5959        }
    6060    }
  • to-imperative/trunk/java/java/refal/plus/Dos.java

    r3758 r4048  
    4343                arg.assign(Expr.empty);
    4444        } catch (ClassCastException _) {
    45             throw new RefalException("Dos", "Arg", "Invalid argument");
     45            throw new RefalException("refal.plus.Dos.Arg", "Invalid argument");
    4646        } catch (NegativeValueException _) {
    47             throw new RefalException("Dos", "Arg", "Invalid argument");
     47            throw new RefalException("refal.plus.Dos.Arg", "Invalid argument");
    4848        } catch (IndexOutOfBoundsException _) {
    49             throw new RefalException("Vector", "VectorRef", "Index out of range");
     49            throw new RefalException("refal.plus.Vector.VectorRef", "Index out of range");
    5050        } catch (ValueOutOfBoundsException _) {
    5151            arg.assign(Expr.empty);
     
    7272            java.lang.System.exit(Util.intValue(returnCode));
    7373        } catch (ClassCastException _) {
    74             throw new RefalException("Dos", "Exit", "Invalid argument");
     74            throw new RefalException("refal.plus.Dos.Exit", "Invalid argument");
    7575        } catch (ValueOutOfBoundsException _) {
    76             throw new RefalException("Dos", "Exit", "Invalid argument");
     76            throw new RefalException("refal.plus.Dos.Exit", "Invalid argument");
    7777        }
    7878    }
     
    9191            rand.assign(BigInteger.valueOf(random.nextInt(Util.uintValue(limit))));
    9292        } catch (ClassCastException _) {
    93             throw new RefalException("Dos", "Random", "Invalid argument");
     93            throw new RefalException("refal.plus.Dos.Random", "Invalid argument");
    9494        } catch (ValueOutOfBoundsException _) {
    95             throw new RefalException("Dos", "Random", "Invalid argument");
     95            throw new RefalException("refal.plus.Dos.Random", "Invalid argument");
    9696        }
    9797    }
     
    102102            Thread.sleep(Util.ulongValue(msec));
    103103        } catch (ClassCastException _) {
    104             throw new RefalException("Dos", "Delay", "Invalid argument");
     104            throw new RefalException("refal.plus.Dos.Delay", "Invalid argument");
    105105        } catch (ValueOutOfBoundsException _) {
    106             throw new RefalException("Dos", "Delay", "Invalid argument");
     106            throw new RefalException("refal.plus.Dos.Delay", "Invalid argument");
    107107        } catch (InterruptedException _) {
    108             throw new RefalException("Dos", "Delay", "Interrupted");
     108            throw new RefalException("refal.plus.Dos.Delay", "Interrupted");
    109109        }
    110110    }
     
    117117            Thread.sleep(Util.ulongValue(Util.getBigInteger(sec).multiply(big1000)));
    118118        } catch (ClassCastException _) {
    119             throw new RefalException("Dos", "Sleep", "Invalid argument");
     119            throw new RefalException("refal.plus.Dos.Sleep", "Invalid argument");
    120120        } catch (ValueOutOfBoundsException _) {
    121             throw new RefalException("Dos", "Sleep", "Invalid argument");
     121            throw new RefalException("refal.plus.Dos.Sleep", "Invalid argument");
    122122        } catch (InterruptedException _) {
    123             throw new RefalException("Dos", "Sleep", "Interrupted");
     123            throw new RefalException("refal.plus.Dos.Sleep", "Interrupted");
    124124        }
    125125    }
  • to-imperative/trunk/java/java/refal/plus/File.java

    r3757 r4048  
    3232            return (new java.io.File(file.toChars())).exists();
    3333        } catch (SecurityException _) {
    34             throw new RefalException("File", "Exists", "Access denied");
     34            throw new RefalException("refal.plus.File.Exists", "Access denied");
    3535        }
    3636    }
     
    4141            return (new java.io.File(file.toChars())).canRead();
    4242        } catch (SecurityException _) {
    43             throw new RefalException("File", "CanRead", "Access denied");
     43            throw new RefalException("refal.plus.File.CanRead", "Access denied");
    4444        }
    4545    }
     
    5050            return (new java.io.File(file.toChars())).canWrite();
    5151        } catch (SecurityException _) {
    52             throw new RefalException("File", "CanWrite", "Access denied");
     52            throw new RefalException("refal.plus.File.CanWrite", "Access denied");
    5353        }
    5454    }
     
    6767            return true;
    6868        } catch (SecurityException _) {
    69             throw new RefalException("File", "CanExec", "Access denied");
     69            throw new RefalException("refal.plus.File.CanExec", "Access denied");
    7070        }
    7171    }
     
    7676            return (new java.io.File(file.toChars())).isDirectory();
    7777        } catch (SecurityException _) {
    78             throw new RefalException("File", "IsDirectory", "Access denied");
     78            throw new RefalException("refal.plus.File.IsDirectory", "Access denied");
    7979        }
    8080    }
     
    8585            return (new java.io.File(file.toChars())).isFile();
    8686        } catch (SecurityException _) {
    87             throw new RefalException("File", "IsFile", "Access denied");
     87            throw new RefalException("refal.plus.File.IsFile", "Access denied");
    8888        }
    8989    }
     
    9494            return (new java.io.File(file.toChars())).delete();
    9595        } catch (SecurityException _) {
    96             throw new RefalException("File", "Delete", "Access denied");
     96            throw new RefalException("refal.plus.File.Delete", "Access denied");
    9797        }
    9898    }
     
    103103            time.assign(Util.newInt(new java.io.File(file.toChars()).lastModified()));
    104104        } catch (SecurityException _) {
    105             throw new RefalException("File", "LastModified", "Access denied");
     105            throw new RefalException("refal.plus.File.LastModified", "Access denied");
    106106        }
    107107    }
  • to-imperative/trunk/java/java/refal/plus/StdIO.java

    r3758 r4048  
    6868        } catch (IOException x) {
    6969            java.lang.String s = x.getMessage();
    70             throw new RefalException("StdIO", "CloseChannel", s != null ? s : x.toString());
     70            throw new RefalException("refal.plus.StdIO.CloseChannel", s != null ? s : x.toString());
    7171        }
    7272    }
     
    8686            return true;
    8787        } catch (ClassCastException _) {
    88             throw new RefalException("StdIO", "PrimRead", "Invalid argument");
     88            throw new RefalException("refal.plus.StdIO.PrimRead", "Invalid argument");
    8989        } catch (ValueOutOfBoundsException _) {
    90             throw new RefalException("StdIO", "PrimRead", "Invalid argument");
    91         } catch (IOException x) {
    92             java.lang.String s = x.getMessage();
    93             throw new RefalException("StdIO", "PrimRead", s != null ? s : x.toString());
     90            throw new RefalException("refal.plus.StdIO.PrimRead", "Invalid argument");
     91        } catch (IOException x) {
     92            java.lang.String s = x.getMessage();
     93            throw new RefalException("refal.plus.StdIO.PrimRead", s != null ? s : x.toString());
    9494        }
    9595    }
     
    110110            getChannel(channel).print(expr.toString());
    111111        } catch (ClassCastException _) {
    112             throw new RefalException("StdIO", "WriteCh", "Invalid argument");
    113         } catch (IOException x) {
    114             java.lang.String s = x.getMessage();
    115             throw new RefalException("StdIO", "WriteCh", s != null ? s : x.toString());
     112            throw new RefalException("refal.plus.StdIO.WriteCh", "Invalid argument");
     113        } catch (IOException x) {
     114            java.lang.String s = x.getMessage();
     115            throw new RefalException("refal.plus.StdIO.WriteCh", s != null ? s : x.toString());
    116116        }
    117117    }
     
    122122            getChannel(channel).println(expr.toString());
    123123        } catch (ClassCastException _) {
    124             throw new RefalException("StdIO", "WriteLnCh", "Invalid argument");
    125         } catch (IOException x) {
    126             java.lang.String s = x.getMessage();
    127             throw new RefalException("StdIO", "WriteLnCh", s != null ? s : x.toString());
     124            throw new RefalException("refal.plus.StdIO.WriteLnCh", "Invalid argument");
     125        } catch (IOException x) {
     126            java.lang.String s = x.getMessage();
     127            throw new RefalException("refal.plus.StdIO.WriteLnCh", s != null ? s : x.toString());
    128128        }
    129129    }
     
    144144            getChannel(channel).print(expr.toChars());
    145145        } catch (ClassCastException _) {
    146             throw new RefalException("StdIO", "PrintCh", "Invalid argument");
    147         } catch (IOException x) {
    148             java.lang.String s = x.getMessage();
    149             throw new RefalException("StdIO", "PrintCh", s != null ? s : x.toString());
     146            throw new RefalException("refal.plus.StdIO.PrintCh", "Invalid argument");
     147        } catch (IOException x) {
     148            java.lang.String s = x.getMessage();
     149            throw new RefalException("refal.plus.StdIO.PrintCh", s != null ? s : x.toString());
    150150        }
    151151    }
     
    156156            getChannel(channel).println(expr.toChars());
    157157        } catch (ClassCastException _) {
    158             throw new RefalException("StdIO", "PrintLnCh", "Invalid argument");
    159         } catch (IOException x) {
    160             java.lang.String s = x.getMessage();
    161             throw new RefalException("StdIO", "PrintLnCh", s != null ? s : x.toString());
     158            throw new RefalException("refal.plus.StdIO.PrintLnCh", "Invalid argument");
     159        } catch (IOException x) {
     160            java.lang.String s = x.getMessage();
     161            throw new RefalException("refal.plus.StdIO.PrintLnCh", s != null ? s : x.toString());
    162162        }
    163163    }
     
    168168            getChannel(channel).flush();
    169169        } catch (ClassCastException _) {
    170             throw new RefalException("StdIO", "Flush", "Invalid argument");
    171         } catch (IOException x) {
    172             java.lang.String s = x.getMessage();
    173             throw new RefalException("StdIO", "Flush", s != null ? s : x.toString());
     170            throw new RefalException("refal.plus.StdIO.Flush", "Invalid argument");
     171        } catch (IOException x) {
     172            java.lang.String s = x.getMessage();
     173            throw new RefalException("refal.plus.StdIO.Flush", s != null ? s : x.toString());
    174174        }
    175175    }
  • to-imperative/trunk/java/java/refal/plus/String.java

    r3745 r4048  
    3333            Symbol.setObject(str, string);
    3434        } catch (ClassCastException _) {
    35             throw new RefalException("String", "String", "Invalid argument");
     35            throw new RefalException("refal.plus.String.String", "Invalid argument");
    3636        }
    3737    }
     
    4242            expr.assign(getString(string).toExpr());
    4343        } catch (ClassCastException _) {
    44             throw new RefalException("Vector", "Vector", "Invalid argument");
     44            throw new RefalException("refal.plus.Vector.Vector", "Invalid argument");
    4545        }
    4646    }
     
    5656                str.add(c);
    5757        } catch (NegativeValueException _) {
    58             throw new RefalException("String", "StringInit", "Invalid argument");
     58            throw new RefalException("refal.plus.String.StringInit", "Invalid argument");
    5959        } catch (ValueOutOfBoundsException _) {
    60             throw new RefalException("String", "StringInit", "Size limit exceeded");
     60            throw new RefalException("refal.plus.String.StringInit", "Size limit exceeded");
    6161        } catch (ClassCastException _) {
    62             throw new RefalException("String", "StringInit", "Invalid argument");
     62            throw new RefalException("refal.plus.String.StringInit", "Invalid argument");
    6363        }
    6464    }
     
    7373                str.set(i, c);
    7474        } catch (ClassCastException _) {
    75             throw new RefalException("String", "StringFill", "Invalid argument");
     75            throw new RefalException("refal.plus.String.StringFill", "Invalid argument");
    7676        }
    7777    }
     
    8282            length.assign(Util.newInt(getString(string).size()));
    8383        } catch (ClassCastException _) {
    84             throw new RefalException("String", "StringLength", "Invalid argument");
     84            throw new RefalException("refal.plus.String.StringLength", "Invalid argument");
    8585        }
    8686    }
     
    9191            ch.assign(getString(string).get(Util.uintValue(index)));
    9292        } catch (NegativeValueException _) {
    93             throw new RefalException("String", "StringRef", "Invalid argument");
     93            throw new RefalException("refal.plus.String.StringRef", "Invalid argument");
    9494        } catch (ValueOutOfBoundsException _) {
    95             throw new RefalException("String", "StringRef", "Index out of range");
     95            throw new RefalException("refal.plus.String.StringRef", "Index out of range");
    9696        } catch (IndexOutOfBoundsException _) {
    97             throw new RefalException("String", "StringRef", "Index out of range");
     97            throw new RefalException("refal.plus.String.StringRef", "Index out of range");
    9898        } catch (ClassCastException _) {
    99             throw new RefalException("String", "StringRef", "Invalid argument");
     99            throw new RefalException("refal.plus.String.StringRef", "Invalid argument");
    100100        }
    101101    }
     
    106106            getString(string).set(Util.uintValue(index), getCharacter(ch));
    107107        } catch (NegativeValueException _) {
    108             throw new RefalException("String", "StringSet", "Invalid argument");
     108            throw new RefalException("refal.plus.String.StringSet", "Invalid argument");
    109109        } catch (ValueOutOfBoundsException _) {
    110             throw new RefalException("String", "StringSet", "Index out of range");
     110            throw new RefalException("refal.plus.String.StringSet", "Index out of range");
    111111        } catch (IndexOutOfBoundsException _) {
    112             throw new RefalException("String", "StringSet", "Index out of range");
     112            throw new RefalException("refal.plus.String.StringSet", "Index out of range");
    113113        } catch (ClassCastException _) {
    114             throw new RefalException("String", "StringSet", "Invalid argument");
     114            throw new RefalException("refal.plus.String.StringSet", "Invalid argument");
    115115        }
    116116    }
     
    123123            str.init(source);
    124124        } catch (ClassCastException _) {
    125             throw new RefalException("String", "StringReplace", "Invalid argument");
     125            throw new RefalException("refal.plus.String.StringReplace", "Invalid argument");
    126126        }
    127127    }
     
    134134            Symbol.setObject(getString(string).subString(s, e), subString);
    135135        } catch (NegativeValueException _) {
    136             throw new RefalException("String", "Substring", "Invalid argument");
     136            throw new RefalException("refal.plus.String.Substring", "Invalid argument");
    137137        } catch (ValueOutOfBoundsException _) {
    138             throw new RefalException("String", "Substring", "Index out of range");
     138            throw new RefalException("refal.plus.String.Substring", "Index out of range");
    139139        } catch (IndexOutOfBoundsException _) {
    140             throw new RefalException("String", "Substring", "Index out of range");
     140            throw new RefalException("refal.plus.String.Substring", "Index out of range");
    141141        } catch (ClassCastException _) {
    142             throw new RefalException("String", "Substring", "Invalid argument");
     142            throw new RefalException("refal.plus.String.Substring", "Invalid argument");
    143143        }
    144144    }
     
    154154                str.set(i, c);
    155155        } catch (NegativeValueException _) {
    156             throw new RefalException("String", "SubvectorFill", "Invalid argument");
     156            throw new RefalException("refal.plus.String.SubvectorFill", "Invalid argument");
    157157        } catch (ValueOutOfBoundsException _) {
    158             throw new RefalException("String", "SubvectorFill", "Index out of range");
     158            throw new RefalException("refal.plus.String.SubvectorFill", "Index out of range");
    159159        } catch (IndexOutOfBoundsException _) {
    160             throw new RefalException("String", "SubstringFill", "Index out of range");
     160            throw new RefalException("refal.plus.String.SubstringFill", "Index out of range");
    161161        } catch (ClassCastException _) {
    162             throw new RefalException("String", "SubstringFill", "Invalid argument");
     162            throw new RefalException("refal.plus.String.SubstringFill", "Invalid argument");
    163163        }
    164164    }
  • to-imperative/trunk/java/java/refal/plus/System.java

    r3757 r4048  
    4848        } catch (InterruptedException e) {
    4949            java.lang.String s = e.getMessage();
    50             throw new RefalException("System", "System", s != null ? s : "Interrupted");
     50            throw new RefalException("refal.plus.System.System", s != null ? s : "Interrupted");
    5151        } catch (IOException e) {
    5252            java.lang.String s = e.getMessage();
    53             throw new RefalException("System", "System", s != null ? s : "Can't execute command");
     53            throw new RefalException("refal.plus.System.System", s != null ? s : "Can't execute command");
    5454        } catch (SecurityException _) {
    55             throw new RefalException("System", "System", "Access denied");
     55            throw new RefalException("refal.plus.System.System", "Access denied");
    5656        } catch (IllegalArgumentException _) {
    57             throw new RefalException("System", "System", "Invalid argument");
     57            throw new RefalException("refal.plus.System.System", "Invalid argument");
    5858        }
    5959    }
  • to-imperative/trunk/java/java/refal/plus/Table.java

    r3745 r4048  
    2929            getTable(table).put(key, value);
    3030        } catch (ClassCastException _) {
    31             throw new RefalException("Table", "Bind", "Invalid argument");
     31            throw new RefalException("refal.plus.Table.Bind", "Invalid argument");
    3232        }
    3333    }
     
    3838            getTable(table).remove(key);
    3939        } catch (ClassCastException _) {
    40             throw new RefalException("Table", "Unbind", "Invalid argument");
     40            throw new RefalException("refal.plus.Table.Unbind", "Invalid argument");
    4141        }
    4242    }
     
    5151            return true;
    5252        } catch (ClassCastException _) {
    53             throw new RefalException("Table", "Lookup", "Invalid argument");
     53            throw new RefalException("refal.plus.Table.Lookup", "Invalid argument");
    5454        }
    5555    }
     
    6060            return getTable(table).containsKey(key);
    6161        } catch (ClassCastException _) {
    62             throw new RefalException("Table", "IsInTable", "Invalid argument");
     62            throw new RefalException("refal.plus.Table.IsInTable", "Invalid argument");
    6363        }
    6464    }
     
    6969            keys.assign(getTable(table).getKeys());
    7070        } catch (ClassCastException _) {
    71             throw new RefalException("Table", "Domain", "Invalid argument");
     71            throw new RefalException("refal.plus.Table.Domain", "Invalid argument");
    7272        }
    7373    }
     
    7979            values.assign(getTable(table).getValues());
    8080        } catch (ClassCastException _) {
    81             throw new RefalException("Table", "Values", "Invalid argument");
     81            throw new RefalException("refal.plus.Table.Values", "Invalid argument");
    8282        }
    8383    }
     
    8888            entries.assign(getTable(table).toExpr());
    8989        } catch (ClassCastException _) {
    90             throw new RefalException("Table", "Entries", "Invalid argument");
     90            throw new RefalException("refal.plus.Table.Entries", "Invalid argument");
    9191        }
    9292    }
     
    9999            Symbol.setObject(tab, tableCopy);
    100100        } catch (ClassCastException _) {
    101             throw new RefalException("Table", "TableCopy", "Invalid argument");
     101            throw new RefalException("refal.plus.Table.TableCopy", "Invalid argument");
    102102        }
    103103    }
     
    110110            tab.putAll(getTable(sourceTable));
    111111        } catch (ClassCastException _) {
    112             throw new RefalException("Table", "ReplaceTable", "Invalid argument");
     112            throw new RefalException("refal.plus.Table.ReplaceTable", "Invalid argument");
    113113        }
    114114    }
     
    119119            getTable(table).clear();
    120120        } catch (ClassCastException _) {
    121             throw new RefalException("Table", "ClearTable", "Invalid argument");
     121            throw new RefalException("refal.plus.Table.ClearTable", "Invalid argument");
    122122        }
    123123    }
     
    128128            size.assign(Util.newInt(getTable(table).size()));
    129129        } catch (ClassCastException _) {
    130             throw new RefalException("Table", "TableSize", "Invalid argument");
     130            throw new RefalException("refal.plus.Table.TableSize", "Invalid argument");
    131131        }
    132132    }
  • to-imperative/trunk/java/java/refal/plus/Vector.java

    r3746 r4048  
    2828            Symbol.setObject(vec, vector);
    2929        } catch (ClassCastException _) {
    30             throw new RefalException("Vector", "Vector", "Invalid argument");
     30            throw new RefalException("refal.plus.Vector.Vector", "Invalid argument");
    3131        }
    3232    }
     
    3737            expr.assign(getVector(vector).toExpr());
    3838        } catch (ClassCastException _) {
    39             throw new RefalException("Vector", "Vector", "Invalid argument");
     39            throw new RefalException("refal.plus.Vector.Vector", "Invalid argument");
    4040        }
    4141    }
     
    5050                vec.add(expr);
    5151        } catch (NegativeValueException _) {
    52             throw new RefalException("Vector", "VectorInit", "Invalid argument");
     52            throw new RefalException("refal.plus.Vector.VectorInit", "Invalid argument");
    5353        } catch (ValueOutOfBoundsException _) {
    54             throw new RefalException("Vector", "VectorInit", "Size limit exceeded");
     54            throw new RefalException("refal.plus.Vector.VectorInit", "Size limit exceeded");
    5555        } catch (ClassCastException _) {
    56             throw new RefalException("Vector", "VectorInit", "Invalid argument");
     56            throw new RefalException("refal.plus.Vector.VectorInit", "Invalid argument");
    5757        }
    5858    }
     
    6666                vec.set(i, expr);
    6767        } catch (ClassCastException _) {
    68             throw new RefalException("Vector", "VectorFill", "Invalid argument");
     68            throw new RefalException("refal.plus.Vector.VectorFill", "Invalid argument");
    6969        }
    7070    }
     
    7575            length.assign(Util.newInt(getVector(vector).size()));
    7676        } catch (ClassCastException _) {
    77             throw new RefalException("Vector", "VectorLength", "Invalid argument");
     77            throw new RefalException("refal.plus.Vector.VectorLength", "Invalid argument");
    7878        }
    7979    }
     
    8484            expr.assign(getVector(vector).get(Util.uintValue(index)));
    8585        } catch (NegativeValueException _) {
    86             throw new RefalException("Vector", "VectorRef", "Invalid argument");
     86            throw new RefalException("refal.plus.Vector.VectorRef", "Invalid argument");
    8787        } catch (ValueOutOfBoundsException _) {
    88             throw new RefalException("Vector", "VectorRef", "Index out of range");
     88            throw new RefalException("refal.plus.Vector.VectorRef", "Index out of range");
    8989        } catch (IndexOutOfBoundsException _) {
    90             throw new RefalException("Vector", "VectorRef", "Index out of range");
     90            throw new RefalException("refal.plus.Vector.VectorRef", "Index out of range");
    9191        } catch (ClassCastException _) {
    92             throw new RefalException("Vector", "VectorRef", "Invalid argument");
     92            throw new RefalException("refal.plus.Vector.VectorRef", "Invalid argument");
    9393        }
    9494    }
     
    9999            getVector(vector).set(Util.uintValue(index), expr);
    100100        } catch (NegativeValueException _) {
    101             throw new RefalException("Vector", "VectorSet", "Invalid argument");
     101            throw new RefalException("refal.plus.Vector.VectorSet", "Invalid argument");
    102102        } catch (ValueOutOfBoundsException _) {
    103             throw new RefalException("Vector", "VectorSet", "Index out of range");
     103            throw new RefalException("refal.plus.Vector.VectorSet", "Index out of range");
    104104        } catch (IndexOutOfBoundsException _) {
    105             throw new RefalException("Vector", "VectorSet", "Index out of range");
     105            throw new RefalException("refal.plus.Vector.VectorSet", "Index out of range");
    106106        } catch (ClassCastException _) {
    107             throw new RefalException("Vector", "VectorSet", "Invalid argument");
     107            throw new RefalException("refal.plus.Vector.VectorSet", "Invalid argument");
    108108        }
    109109    }
     
    116116            vec.init(source);
    117117        } catch (ClassCastException _) {
    118             throw new RefalException("Vector", "VectorReplace", "Invalid argument");
     118            throw new RefalException("refal.plus.Vector.VectorReplace", "Invalid argument");
    119119        }
    120120    }
     
    127127            Symbol.setObject(getVector(vector).subVector(s, e), subvector);
    128128        } catch (NegativeValueException _) {
    129             throw new RefalException("Vector", "Subvector", "Invalid argument");
     129            throw new RefalException("refal.plus.Vector.Subvector", "Invalid argument");
    130130        } catch (ValueOutOfBoundsException _) {
    131             throw new RefalException("Vector", "Subvector", "Index out of range");
     131            throw new RefalException("refal.plus.Vector.Subvector", "Index out of range");
    132132        } catch (IndexOutOfBoundsException _) {
    133             throw new RefalException("Vector", "Subvector", "Index out of range");
     133            throw new RefalException("refal.plus.Vector.Subvector", "Index out of range");
    134134        } catch (ClassCastException _) {
    135             throw new RefalException("Vector", "Subvector", "Invalid argument");
     135            throw new RefalException("refal.plus.Vector.Subvector", "Invalid argument");
    136136        }
    137137    }
     
    146146                vec.set(i, expr);
    147147        } catch (NegativeValueException _) {
    148             throw new RefalException("Vector", "SubvectorFill", "Invalid argument");
     148            throw new RefalException("refal.plus.Vector.SubvectorFill", "Invalid argument");
    149149        } catch (ValueOutOfBoundsException _) {
    150             throw new RefalException("Vector", "SubvectorFill", "Index out of range");
     150            throw new RefalException("refal.plus.Vector.SubvectorFill", "Index out of range");
    151151        } catch (IndexOutOfBoundsException _) {
    152             throw new RefalException("Vector", "SubvectorFill", "Index out of range");
     152            throw new RefalException("refal.plus.Vector.SubvectorFill", "Index out of range");
    153153        } catch (ClassCastException _) {
    154             throw new RefalException("Vector", "SubvectorFill", "Invalid argument");
     154            throw new RefalException("refal.plus.Vector.SubvectorFill", "Invalid argument");
    155155        }
    156156    }
  • to-imperative/trunk/java/java/refal/plus/internal/Convert.java

    r3759 r4048  
    4646            res.assign(concat.yield());
    4747        } catch (ClassCastException _) {
    48             throw new RefalException("Convert", "ToLower", "Invalid argument");
     48            throw new RefalException("refal.plus.Convert.ToLower", "Invalid argument");
    4949        }
    5050    }
     
    5858            res.assign(concat.yield());
    5959        } catch (ClassCastException _) {
    60             throw new RefalException("Convert", "ToUpper", "Invalid argument");
     60            throw new RefalException("refal.plus.Convert.ToUpper", "Invalid argument");
    6161        }
    6262    }
     
    7070            bytes.assign(concat.yield());
    7171        } catch (ClassCastException _) {
    72             throw new RefalException("Convert", "CharsToBytes", "Invalid argument");
     72            throw new RefalException("refal.plus.Convert.CharsToBytes", "Invalid argument");
    7373        }
    7474    }
     
    8282            chars.assign(concat.yield());
    8383        } catch (ValueOutOfBoundsException _) {
    84             throw new RefalException("Convert", "BytesToChars", "Invalid argument");
     84            throw new RefalException("refal.plus.Convert.BytesToChars", "Invalid argument");
    8585        } catch (ClassCastException _) {
    86             throw new RefalException("Convert", "BytesToChars", "Invalid argument");
     86            throw new RefalException("refal.plus.Convert.BytesToChars", "Invalid argument");
    8787        }
    8888    }
  • to-imperative/trunk/java/refal/refal/plus/Lexer.rf

    r3831 r4048  
    6464            e.Isstop : Stop;
    6565          t1  =
    66             <Error stream "Invalid character '" t1 "'">,
     66            <Error stream "Invalid character" t1>,
    6767            $fail;
    6868        };
     
    221221          '\n' = (e.s) s.max;
    222222          s1   =
    223             <Error stream "Unknown control sequence '\\" s1 "'">,
     223            <Error stream "Unknown control sequence" '\\' s1>,
    224224            (e.s s1) <Sub s.max 1>;
    225225          t1   =
    226             <Error stream "Bad symbol '" t1 "'">, (e.s) s.max;
     226            <Error stream "Bad symbol" t1>, (e.s) s.max;
    227227        };
    228228        <Error_At t.pos "Unclosed quotes">, (e.s) 0;
     
    230230      '\n' = (e.s '\n') <Sub s.max 1>; //FIXME: should be option-controlled!
    231231      s1 = (e.s s1) <Sub s.max 1>;
    232       t1 = <Error stream "Invalid character '" t1 "'">, (e.s) s.max;
     232      t1 = <Error stream "Invalid character" t1>, (e.s) s.max;
    233233    };
    234234    <Error_At t.pos "Unclosed quotes">, (e.s) 0;
     
    302302      };
    303303    <Getc stream> : t1 =
    304       <Error stream "Invalid character '" t1 "'">,
     304      <Error stream "Invalid character" t1>,
    305305      <Read_Term_Aux stream>;
    306306  };
  • to-imperative/trunk/java/refal/refal/plus/Stream.rf

    r3974 r4048  
    33//$module Stream : IStream;
    44
    5 $use Access Apply Arithm Box Class Compare Error StdIO;
     5$use Access Apply Arithm Box Class Compare StdIO;
    66
    77//** $func Stream s.func e.args = stream;
     
    99Stream s.func e.args, {
    1010  # <IsFunc s.func> =
    11     <Lib_Error (Stream Stream) "Arg 1 is not a Function">, $fail;
     11    $error "refal.plus.Stream.Stream" "Invalid argument" 1 "Not a function" s.func;
    1212  <Box () (s.func e.args)>;
    1313};
     
    4040    e.args : s.ch e.rest, <IsChannel s.ch> =
    4141      <PrimCloseChannel s.ch>;
    42     <Lib_Error (Stream "File_Close") "Arg 1 is not a Streamed File"> = $fail;
     42    $error "refal.plus.Stream.File_Close" "Invalid argument" 1 "Not a streamed file";
    4343  };
    44   <Lib_Error (Stream "File_Close") "Arg 1 is not a Stream"> = $fail;
     44  $error "refal.plus.Stream.File_Close" "Invalid argument" 1 "Not a stream" stream;
    4545};
    4646
     
    6868    <Store stream (e.tail) (s.func e.args)>,
    6969    t.head;
    70   <Lib_Error (Stream Getc) "Arg 1 is not a Stream"> = $fail;
     70  $error "refal.plus.Stream.Getc" "Invalid argument" 1 "Not a stream" stream;
    7171};
    7272
     
    8181    <Store stream (<Middle s.n 0 e.buf>) (s.func e.args)>,
    8282    <Left 0 s.n e.buf>;
    83   <Lib_Error (Stream Gets) "Arg 1 is not a Stream"> = $fail;
     83  $error "refal.plus.Stream.Gets" "Invalid argument" 1 "Not a stream" stream;
    8484};
    8585
     
    9090  <Get stream> : (e.buf) (s.func e.args) =
    9191    <Store stream (expr e.buf) (s.func e.args)>;
    92   <Lib_Error (Stream Ungets) "Arg 1 is not a Stream"> = $fail;
     92  $error "refal.plus.Stream.Ungets" "Invalid argument" 1 "Not a stream" stream;
    9393};
    9494
     
    126126    <Store stream (e.buf) (s.func e.args)>,
    127127    e.str;
    128   <Lib_Error (Stream "Get_Delims") "Arg 1 is not a Stream"> = $fail;
     128  $error "refal.plus.Stream.Get_Delims" "Invalid argument" 1 "Not a stream" stream;
    129129};
    130130
     
    140140    <Store stream (e.buf) (s.func e.args)>,
    141141    e.str;
    142   <Lib_Error (Stream "Get_Delim") "Arg 1 is not a Stream"> = $fail;
     142  $error "refal.plus.Stream.Get_Delim" "Invalid argument" 1 "Not a stream" stream;
    143143};
    144144
     
    166166    <Store stream (e.buf) (s.func e.args)>,
    167167    e.str;
    168   <Lib_Error (Stream "Get_While") "Arg 1 is not a Stream"> = $fail;
     168  $error "refal.plus.Stream.Get_While" "Invalid argument" 1 "Not a stream" stream;
    169169};
    170170
     
    178178    <Store stream (e.buf) (s.func e.args)>,
    179179    e.str;
    180   <Lib_Error (Stream "Get_Until") "Arg 1 is not a Stream"> = $fail;
     180  $error "refal.plus.Stream.Get_Until" "Invalid argument" 1 "Not a stream" stream;
    181181};
    182182
     
    194194      /*We are at the end of the stream*/;
    195195    };
    196   <Lib_Error (Stream "IsEnd_of_Stream") "Arg 1 is not a Stream"> = $fail;
     196  $error "refal.plus.Stream.IsEnd_of_Stream" "Invalid argument" 1 "Not a stream" stream;
    197197};
    198198
  • to-imperative/trunk/java/refal/refal/plus/internal/StdIO.rf

    r3659 r4048  
    11// $Id$
    22
    3 $use Arithm Box Class Compare Convert Error Table;
     3$use Arithm Box Class Compare Convert Table;
    44
    55//X/$use Lexer(Stream FakeStreamIndex);
     
    1111OpenFile s.channel e.file s.mode, \{
    1212  # <IsChannel s.channel> =
    13     <Lib_Error (StdIO OpenFile) "Arg 1 is not a Channel">;
     13      $error "refal.plus.StdIO.OpenFile" "Invalid argument" 1 "Not a channel" s.channel;
    1414  # <IsWord s.mode> =
    15     <Lib_Error (StdIO OpenFile) "Arg 3 is not a Word">;
     15      $error "refal.plus.StdIO.OpenFile" "Invalid argument" 3 "Not a word" s.mode;
    1616  <PrimOpenFile s.channel e.file s.mode>,
    1717    <Bind &Buffers (s.channel) (<Stream &PrimRead s.channel &ReadChunkSize>)>;
     
    2828CloseChannel s.channel, {
    2929  # <IsChannel s.channel> =
    30     <Lib_Error (StdIO CloseChannel) "Arg 1 is not a Channel">;
     30    $error "refal.plus.StdIO.CloseChannel" "Invalid argument" 1 "Not a channel" s.channel;
    3131  <PrimCloseChannel s.channel>,
    3232    <Unbind &Buffers s.channel>;
     
    3737  <Lookup &Buffers s.channel> : stream =
    3838    <IsEnd_of_Stream stream>;
    39   <Lib_Error (StdIO IsEof) "Channel is not open">;
     39  $error "refal.plus.StdIO.CloseChannel" "Channel is not open" s.channel;
    4040};
    4141
     
    4444  <Lookup &Buffers s.channel> : stream =
    4545    <Getc stream> : s.char, s.char;
    46   <Lib_Error (StdIO ReadCharCh) "Channel is not open"> = $fail;
     46  $error "refal.plus.StdIO.ReadCharCh" "Channel is not open" s.channel;
    4747};
    4848
     
    5858      v.line        = v.line;
    5959    };
    60   <Lib_Error (StdIO ReadLineCh) "Channel is not open"> = $fail;
     60  $error "refal.plus.StdIO.ReadLineCh" "Channel is not open" s.channel;
    6161};
    6262
     
    7878    {
    7979      <Errors> : (t.name t.pos (e.message)) e =
    80         <Lib_Error (StdIO s.fname) e.message>, $fail;;
     80        $error <ToWord "refal.plus.StdIO."s.fname> e.message;;
    8181    },
    8282    e.result : term = term;
    83   <Lib_Error (StdIO s.fname) "Channel is not open"> = $fail;
     83  $error <ToWord "refal.plus.StdIO."s.fname> "Channel is not open" s.channel;
    8484};
    8585
Note: See TracChangeset for help on using the changeset viewer.