Changeset 9974


Ignore:
Timestamp:
09/14/05 19:58:25 (16 years ago)
Author:
piso
Message:

Work in progress (tested).

File:
1 edited

Legend:

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

    r9970 r9974  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Pathname.java,v 1.88 2005-09-14 13:41:34 piso Exp $
     5 * $Id: Pathname.java,v 1.89 2005-09-14 19:58:25 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    734734        if (args.length % 2 != 0)
    735735            signal(new ProgramError("Odd number of keyword arguments."));
    736         Pathname p = new Pathname();
     736        LispObject host = NIL;
     737        LispObject device = NIL;
     738        LispObject directory = NIL;
     739        LispObject name = NIL;
     740        LispObject type = NIL;
     741        LispObject version = NIL;
    737742        Pathname defaults = null;
    738743        boolean deviceSupplied = false;
     
    743748            LispObject value = args[i+1];
    744749            if (key == Keyword.HOST) {
    745                 p.host = value;
     750                host = value;
    746751            } else if (key == Keyword.DEVICE) {
    747                 p.device = value;
     752                device = value;
    748753                deviceSupplied = true;
    749754            } else if (key == Keyword.DIRECTORY) {
    750755                if (value instanceof AbstractString)
    751                     p.directory = list2(Keyword.ABSOLUTE, value);
     756                    directory = list2(Keyword.ABSOLUTE, value);
    752757                else if (value == Keyword.WILD)
    753                     p.directory = list2(Keyword.ABSOLUTE, Keyword.WILD);
     758                    directory = list2(Keyword.ABSOLUTE, Keyword.WILD);
    754759                else
    755                     p.directory = value;
     760                    directory = value;
    756761            } else if (key == Keyword.NAME) {
    757                 p.name = value;
     762                name = value;
    758763                nameSupplied = true;
    759764            } else if (key == Keyword.TYPE) {
    760                 p.type = value;
     765                type = value;
    761766                typeSupplied = true;
    762767            } else if (key == Keyword.VERSION) {
    763                 p.version = value;
     768                version = value;
    764769            } else if (key == Keyword.DEFAULTS) {
    765770                defaults = coerceToPathname(value);
     
    770775        if (defaults != null) {
    771776            // Ignore host.
    772             p.directory = mergeDirectories(p.directory, defaults.directory);
     777            directory = mergeDirectories(directory, defaults.directory);
    773778            if (!deviceSupplied)
    774                 p.device = defaults.device;
     779                device = defaults.device;
    775780            if (!nameSupplied)
    776                 p.name = defaults.name;
     781                name = defaults.name;
    777782            if (!typeSupplied)
    778                 p.type = defaults.type;
    779         }
     783                type = defaults.type;
     784        }
     785        final Pathname p;
     786        final boolean logical;
     787        if (host != NIL) {
     788            if (LOGICAL_PATHNAME_TRANSLATIONS.get(host) == null) {
     789                // Not a defined logical pathname host.
     790                signal(new LispError(host.writeToString() + " is not defined as a logical pathname host."));
     791            }
     792            p = new LogicalPathname();
     793            logical = true;
     794            p.host = host;
     795        } else {
     796            p = new Pathname();
     797            logical = false;
     798        }
     799        if (device != NIL) {
     800            if (logical && device instanceof AbstractString)
     801                p.device = new SimpleString(device.getStringValue().toUpperCase());
     802            else
     803                p.device = device;
     804        }
     805        if (directory != NIL) {
     806            if (logical && directory.listp()) {
     807                LispObject d = NIL;
     808                while (d != NIL) {
     809                    LispObject component = directory.car();
     810                    if (component instanceof AbstractString)
     811                        d = d.push(new SimpleString(component.getStringValue().toUpperCase()));
     812                    else
     813                        d = d.push(component);
     814                    directory = directory.cdr();
     815                }
     816                p.directory = d.nreverse();
     817            } else
     818                p.directory = directory;
     819        }
     820        if (name != NIL) {
     821            if (logical && name instanceof AbstractString)
     822                p.name = new SimpleString(name.getStringValue().toUpperCase());
     823            else
     824                p.name = name;
     825        }
     826        if (type != NIL) {
     827            if (logical && type instanceof AbstractString)
     828                p.type = new SimpleString(type.getStringValue().toUpperCase());
     829            else
     830                p.type = type;
     831        }
     832        p.version = version;
    780833        return p;
    781834    }
     
    848901        {
    849902            Pathname pathname = Pathname.coerceToPathname(arg);
     903            if (pathname instanceof LogicalPathname) {
     904                try {
     905                    pathname = (Pathname) Symbol.TRANSLATE_LOGICAL_PATHNAME.execute(pathname);
     906                }
     907                catch (ClassCastException e) {
     908                    return signalTypeError(pathname, Symbol.PATHNAME);
     909                }
     910            }
    850911            LispObject result = NIL;
    851912            String s = pathname.getNamestring();
     
    10511112        throws ConditionThrowable
    10521113    {
    1053         final Pathname pathname = Pathname.coerceToPathname(arg);
     1114        Pathname pathname = Pathname.coerceToPathname(arg);
     1115        if (pathname instanceof LogicalPathname) {
     1116            try {
     1117                pathname = (Pathname) Symbol.TRANSLATE_LOGICAL_PATHNAME.execute(pathname);
     1118            }
     1119            catch (ClassCastException e) {
     1120                return signalTypeError(pathname, Symbol.PATHNAME);
     1121            }
     1122        }
    10541123        if (pathname.isWild())
    10551124            return signal(new FileError("Bad place for a wild pathname.",
Note: See TracChangeset for help on using the changeset viewer.