Changeset 5292


Ignore:
Timestamp:
12/31/03 19:40:13 (17 years ago)
Author:
piso
Message:

New implementation.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/Pathname.java

    r5114 r5292  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Pathname.java,v 1.21 2003-12-13 00:58:51 piso Exp $
     5 * $Id: Pathname.java,v 1.22 2003-12-31 19:40:13 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424import java.io.File;
    2525
    26 // FIXME Not much of an implementation...
    2726public final class Pathname extends LispObject
    2827{
     28    private LispObject host = NIL;
     29    private LispObject device = NIL;
     30    private LispObject directory = NIL;
     31    private LispObject name = NIL;
     32
     33    // A string, NIL, :wild or :unspecific.
     34    private LispObject type = NIL;
     35
     36    // A positive integer, or NIL, :wild, :unspecific, or :newest.
     37    private LispObject version = NIL;
     38
    2939    private String namestring;
    3040
     41    private Pathname()
     42    {
     43    }
     44
    3145    private Pathname(String namestring)
    3246    {
    3347        this.namestring = namestring;
     48        if (namestring != null) {
     49            for (int i = namestring.length(); i-- > 0;) {
     50                char c = namestring.charAt(i);
     51                if (c == '/' || c == '\\') {
     52                    directory = new LispString(namestring.substring(0, i + 1));
     53                    String s = namestring.substring(i + 1);
     54                    int index = s.lastIndexOf('.');
     55                    if (index >= 0) {
     56                        name = new LispString(s.substring(0, index));
     57                        type = new LispString(s.substring(index + 1));
     58                    } else
     59                        name = new LispString(s);
     60                    break;
     61                }
     62            }
     63            if (name == NIL)
     64                name = new LispString(namestring);
     65        }
    3466    }
    3567
     
    69101    public String getNamestring()
    70102    {
    71         return namestring;
    72     }
    73 
    74     public boolean equal(LispObject obj)
     103        if (namestring != null)
     104            return namestring;
     105        StringBuffer sb = new StringBuffer();
     106        if (directory instanceof LispString)
     107            sb.append(((LispString)directory).getValue());
     108        if (sb.length() > 0 && sb.charAt(sb.length() - 1) != File.separatorChar)
     109            sb.append(File.separatorChar);
     110        if (name instanceof LispString)
     111            sb.append(((LispString)name).getValue());
     112        if (type instanceof LispString) {
     113            sb.append('.');
     114            sb.append(((LispString)type).getValue());
     115        }
     116        return namestring = sb.toString();
     117    }
     118
     119    public boolean equal(LispObject obj) throws ConditionThrowable
    75120    {
    76121        if (this == obj)
    77122            return true;
    78123        if (obj instanceof Pathname) {
    79             if (Utilities.isPlatformWindows())
    80                 return namestring.equalsIgnoreCase(((Pathname)obj).getNamestring());
    81             return namestring.equals(((Pathname)obj).getNamestring());
     124            Pathname p = (Pathname) obj;
     125            if (Utilities.isPlatformWindows()) {
     126                if (!host.equalp(p.host))
     127                    return false;
     128                if (!device.equalp(p.device))
     129                    return false;
     130                if (!directory.equalp(p.directory))
     131                    return false;
     132                if (!name.equalp(p.name))
     133                    return false;
     134                if (!type.equalp(p.type))
     135                    return false;
     136                if (!version.equalp(p.version))
     137                    return false;
     138            } else {
     139                if (!host.equal(p.host))
     140                    return false;
     141                if (!device.equal(p.device))
     142                    return false;
     143                if (!directory.equal(p.directory))
     144                    return false;
     145                if (!name.equal(p.name))
     146                    return false;
     147                if (!type.equal(p.type))
     148                    return false;
     149                if (!version.equal(p.version))
     150                    return false;
     151            }
     152            return true;
    82153        }
    83154        return false;
     
    94165
    95166    public static Pathname parseNamestring(String namestring)
    96         throws ConditionThrowable
    97167    {
    98168        return new Pathname(namestring);
     
    102172    // namestring pathname => namestring
    103173    // FIXME arg can be a stream, too...
    104     private static final Primitive1 NAMESTRING = new Primitive1("namestring","pathname")
     174    private static final Primitive1 NAMESTRING = new Primitive1("namestring", "pathname")
    105175    {
    106176        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    158228    // %make-pathname host device directory name type version defaults case =>
    159229    // pathname
    160     // FIXME Very incomplete.
     230    // FIXME Incomplete.
    161231    private static final Primitive _MAKE_PATHNAME =
    162232        new Primitive("%make-pathname", PACKAGE_SYS, false)
     
    166236            if (args.length != 8)
    167237                return signal(new WrongNumberOfArgumentsException(this));
    168             LispObject host = args[0];
    169             LispObject device = args[1];
    170             LispObject directory = args[2];
    171             LispObject name = args[3];
    172             LispObject type = args[4];
    173             LispObject version = args[5]; // Ignored.
     238            Pathname p = new Pathname();
     239            p.host = args[0];
     240            p.device = args[1];
     241            p.directory = args[2];
     242            p.name = args[3];
     243            p.type = args[4];
     244            p.version = args[5]; // Ignored.
    174245            LispObject defaults = args[6];
    175246            LispObject _case = args[7]; // Ignored.
    176             // FIXME
    177             if (host != NIL || device != NIL || directory != NIL)
    178                 return signal(new LispError("MAKE-PATHNAME: not implemented"));
    179             String d = ""; // directory
    180             String n = ""; // name
    181             String t = ""; // type
    182             String defaultNamestring = null;
    183             if (defaults instanceof Pathname)
    184                 defaultNamestring = ((Pathname)defaults).getNamestring();
    185             else if (defaults instanceof LispString)
    186                 defaultNamestring = ((LispString)defaults).getValue();
    187             if (defaultNamestring != null) {
    188                 File file = new File(defaultNamestring);
    189                 d = file.getParent();
    190                 n = file.getName();
    191                 int index = n.lastIndexOf('.');
    192                 if (index >= 0) {
    193                     t = n.substring(index + 1);
    194                     n = n.substring(0, index);
    195                 }
    196             }
    197             if (name == Keyword.WILD)
    198                 n = "*";
    199             else if (name instanceof LispString)
    200                 n = ((LispString)name).getValue();
    201             if (type == Keyword.WILD)
    202                 t = "*";
    203             else if (type instanceof LispString)
    204                 t = ((LispString)type).getValue();
    205             if (t.length() > 0)
    206                 n = n + "." + t;
    207             return new Pathname(d, n);
     247            return p;
    208248        }
    209249    };
    210250
    211251    // ### pathnamep
    212     private static final Primitive1 PATHNAMEP = new Primitive1("pathnamep","object")
     252    private static final Primitive1 PATHNAMEP =
     253        new Primitive1("pathnamep", "object")
    213254    {
    214255        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    219260
    220261    // ### pathname-type
    221     private static final Primitive1 PATHNAME_TYPE = new Primitive1("pathname-type","pathname &key case")
     262    private static final Primitive1 PATHNAME_TYPE =
     263        new Primitive1("pathname-type", "pathname &key case")
    222264    {
    223265        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    244286    // user-homedir-pathname &optional host => pathname
    245287    private static final Primitive USER_HOMEDIR_PATHNAME =
    246         new Primitive("user-homedir-pathname","&optional host")
     288        new Primitive("user-homedir-pathname", "&optional host")
    247289    {
    248290        public LispObject execute(LispObject[] args) throws ConditionThrowable
Note: See TracChangeset for help on using the changeset viewer.