Changeset 5106


Ignore:
Timestamp:
12/12/03 17:32:04 (18 years ago)
Author:
piso
Message:

WARN

File:
1 edited

Legend:

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

    r5100 r5106  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.524 2003-12-12 16:18:48 piso Exp $
     5 * $Id: Primitives.java,v 1.525 2003-12-12 17:32:04 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    11701170
    11711171    // ### error
    1172     private static final Primitive ERROR = new Primitive("error","datum &rest arguments")
     1172    private static final Primitive ERROR = new Primitive("error", "datum &rest arguments")
    11731173    {
    11741174        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    11801180                throw new ConditionThrowable((Condition)datum);
    11811181            if (datum instanceof Symbol) {
    1182                 LispObject initargs = NIL;
     1182                LispObject initArgs = NIL;
    11831183                for (int i = 1; i < args.length; i++)
    1184                     initargs = new Cons(args[i], initargs);
    1185                 initargs = initargs.nreverse();
     1184                    initArgs = new Cons(args[i], initArgs);
     1185                initArgs = initArgs.nreverse();
    11861186                Condition condition;
    11871187                if (datum == Symbol.PACKAGE_ERROR)
    1188                     condition = new PackageError(initargs);
     1188                    condition = new PackageError(initArgs);
    11891189                else if (datum == Symbol.PARSE_ERROR)
    1190                     condition = new ParseError(initargs);
     1190                    condition = new ParseError(initArgs);
    11911191                else if (datum == Symbol.PROGRAM_ERROR)
    1192                     condition = new ProgramError(initargs);
     1192                    condition = new ProgramError(initArgs);
    11931193                else if (datum == Symbol.SIMPLE_CONDITION)
    1194                     condition = new SimpleCondition(initargs);
     1194                    condition = new SimpleCondition(initArgs);
    11951195                else if (datum == Symbol.SIMPLE_WARNING)
    1196                     condition = new SimpleWarning(initargs);
     1196                    condition = new SimpleWarning(initArgs);
    11971197                else if (datum == Symbol.WARNING)
    1198                     condition = new Warning(initargs);
     1198                    condition = new Warning(initArgs);
    11991199                else if (datum == Symbol.SIMPLE_ERROR)
    1200                     condition = new SimpleError(initargs);
     1200                    condition = new SimpleError(initArgs);
    12011201                else if (datum == Symbol.TYPE_ERROR)
    1202                     condition = new TypeError(initargs);
     1202                    condition = new TypeError(initArgs);
    12031203                else
    12041204                    // Default.
    1205                     condition = new  SimpleError(initargs);
     1205                    condition = new  SimpleError(initArgs);
    12061206                throw new ConditionThrowable(condition);
    12071207            }
     
    12131213            throw new ConditionThrowable(new SimpleError(formatControl,
    12141214                                                         formatArguments));
     1215        }
     1216    };
     1217
     1218    // ### warn
     1219    private static final Primitive WARN = new Primitive("warn", "datum &rest arguments")
     1220    {
     1221        public LispObject execute(LispObject[] args) throws ConditionThrowable
     1222        {
     1223            if (args.length < 1)
     1224                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     1225            final CharacterOutputStream out =
     1226                checkCharacterOutputStream(_ERROR_OUTPUT_.symbolValue());
     1227            LispObject datum = args[0];
     1228            Condition condition;
     1229            if (datum instanceof Condition) {
     1230                condition = (Condition) datum;
     1231            } else if (datum instanceof Symbol) {
     1232                LispObject initArgs = NIL;
     1233                for (int i = 1; i < args.length; i++)
     1234                    initArgs = new Cons(args[i], initArgs);
     1235                initArgs = initArgs.nreverse();
     1236                if (datum == Symbol.WARNING)
     1237                    condition = new Warning(initArgs);
     1238                else if (datum == Symbol.SIMPLE_WARNING)
     1239                    condition = new SimpleWarning(initArgs);
     1240                else
     1241                    throw new ConditionThrowable(new TypeError(datum,
     1242                                                               Symbol.WARNING));
     1243            } else {
     1244                // Default is SIMPLE-WARNING.
     1245                LispObject formatControl = args[0];
     1246                LispObject formatArguments = NIL;
     1247                for (int i = 1; i < args.length; i++)
     1248                    formatArguments = new Cons(formatArguments, new Cons(args[i]));
     1249                condition = new SimpleWarning(formatControl, formatArguments);
     1250            }
     1251            final LispThread thread = LispThread.currentThread();
     1252            Environment oldDynEnv = thread.getDynamicEnvironment();
     1253            thread.bindSpecial(_PRINT_ESCAPE_, NIL);
     1254            try {
     1255                out.freshLine();
     1256                out.princ(condition);
     1257            }
     1258            finally {
     1259                thread.setDynamicEnvironment(oldDynEnv);
     1260            }
     1261            return NIL;
    12151262        }
    12161263    };
     
    12921339    private static final String _format(LispObject[] args) throws ConditionThrowable
    12931340    {
    1294         final LispThread thread = LispThread.currentThread();
    1295         String control = checkString(args[0]).getValue();
    1296         StringBuffer sb = new StringBuffer();
    1297         final int limit = control.length();
    1298         int j = 1;
    1299         final int NEUTRAL = 0;
    1300         final int TILDE = 1;
    1301         int state = NEUTRAL;
    1302         for (int i = 0; i < limit; i++) {
    1303             char c = control.charAt(i);
    1304             if (state == NEUTRAL) {
    1305                 if (c == '~')
    1306                     state = TILDE;
    1307                 else
    1308                     sb.append(c);
    1309             } else if (state == TILDE) {
    1310                 if (c == 'A' || c == 'a') {
    1311                     if (j < args.length) {
    1312                         LispObject obj = args[j++];
    1313                         Environment oldDynEnv = thread.getDynamicEnvironment();
    1314                         thread.bindSpecial(_PRINT_ESCAPE_, NIL);
    1315                         sb.append(String.valueOf(obj));
    1316                         thread.setDynamicEnvironment(oldDynEnv);
    1317                     }
    1318                 } else if (c == 'S' || c == 's') {
    1319                     if (j < args.length) {
    1320                         LispObject obj = args[j++];
    1321                         Environment oldDynEnv = thread.getDynamicEnvironment();
    1322                         thread.bindSpecial(_PRINT_ESCAPE_, T);
    1323                         sb.append(String.valueOf(obj));
    1324                         thread.setDynamicEnvironment(oldDynEnv);
    1325                     }
    1326                 } else if (c == 'D' || c == 'd') {
    1327                     if (j < args.length) {
    1328                         LispObject obj = args[j++];
    1329                         Environment oldDynEnv = thread.getDynamicEnvironment();
    1330                         thread.bindSpecial(_PRINT_ESCAPE_, NIL);
    1331                         thread.bindSpecial(_PRINT_RADIX_, NIL);
    1332                         thread.bindSpecial(_PRINT_BASE_, new Fixnum(10));
    1333                         sb.append(String.valueOf(obj));
    1334                         thread.setDynamicEnvironment(oldDynEnv);
    1335                     }
    1336                 } else if (c == 'X' || c == 'x') {
    1337                     if (j < args.length) {
    1338                         LispObject obj = args[j++];
    1339                         Environment oldDynEnv = thread.getDynamicEnvironment();
    1340                         thread.bindSpecial(_PRINT_ESCAPE_, NIL);
    1341                         thread.bindSpecial(_PRINT_RADIX_, NIL);
    1342                         thread.bindSpecial(_PRINT_BASE_, new Fixnum(16));
    1343                         sb.append(String.valueOf(obj));
    1344                         thread.setDynamicEnvironment(oldDynEnv);
    1345                     }
    1346                 } else if (c == '%') {
    1347                     sb.append(System.getProperty("line.separator"));
    1348                 }
    1349 //                 else
    1350 //                     throw new ConditionThrowable(new LispError("FORMAT: not implemented"));
    1351                 state = NEUTRAL;
    1352             } else {
    1353                 // There are no other valid states.
    1354                 Debug.assertTrue(false);
    1355             }
    1356         }
    1357         return sb.toString();
     1341        LispObject formatControl = args[0];
     1342        LispObject formatArguments = NIL;
     1343        for (int i = 1; i < args.length; i++)
     1344            formatArguments = new Cons(args[i], formatArguments);
     1345        formatArguments = formatArguments.nreverse();
     1346        return format(formatControl, formatArguments);
    13581347    }
    13591348
Note: See TracChangeset for help on using the changeset viewer.