献上lisp-style计算器

原创 2013年01月13日 23:40:45
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.List;
import java.util.ArrayList;
public class LispCalculator{
    public static final Pattern operateP = Pattern.compile("\\s*([^\\s\\(\\)]+)");
    public static final Pattern numP = Pattern.compile("\\s+([\\+\\-]?(?:(?:[1-9]\\d*)|(?:\\.\\d+)|(?:\\d+\\.\\d+)))");
    public static final Pattern bracketP = Pattern.compile("\\s*(\\(|\\))");

    public static final List<Pattern> tokenPs = new ArrayList<Pattern>();

    /** decimal match pattern **/
    public static final Pattern decimalP = Pattern.compile("[\\+\\-]?(?:(?:\\.\\d+)|(?:\\d+\\.\\d+))");

    /** integer match pattern **/
    public static final Pattern integerP = Pattern.compile("[\\+\\-]?[1-9]\\d*");

    /** if output debug info **/
    public static boolean debug = false;

    static{
        tokenPs.add(operateP);
        tokenPs.add(numP);
        tokenPs.add(bracketP);
    }
    
    private String token;
    private String exp;
    private String origExp;
    
    private void readToken(){
        token = null;
        for(Pattern p:tokenPs){
            Matcher m = p.matcher(exp);
            if(m.lookingAt()){
                token = m.group(1);
                int end = m.end();
                exp = exp.substring(end);
                break;
            }
        }

    }

    public double eval(String exp){
        this.exp = exp;
        this.origExp = new String(exp);
        double ret = -1;
        readToken();
        while(token != null){
            ret = exp1();
        }

        return ret;
    }

    private boolean peek(String str){
        return token == null || str.equals(token);
    }
    private boolean accept(String str){
        if(str.equals(token)){
            readToken();
            return true;
        }
        return false;
    }

    private boolean expect(String str){
        if(accept(str) == false){
            if(token != null)
                System.err.printf("unexpected token %s, expect \"%s\"\n",token,str);
            else
                System.err.printf("has no more token, expect \"%s\"\n",str);
            System.exit(1);
        }
        return true;
    }

    private void debug(String info){
        if(debug){
            System.out.println(info);
        }
    }

    private void debug(String templ, Object... args){
        if(debug){
            System.out.printf(templ, args);
        }
    }


    private boolean isInteger(String token){
        return integerP.matcher(token).matches();
    }

    private String delPlus(String token){
        if(token.startsWith("+")){
            token = token.substring(1);
        }

        return token;
    }

    private int parseInteger(String token){
        token = delPlus(token);
        return Integer.parseInt(token);
    }

    private boolean isDecimal(String token){
        return decimalP.matcher(token).matches();
    }

    private double parseDecimal(String token){
        token = delPlus(token);
        return Double.parseDouble(token);
    }

    public static final Pattern numRegExp = Pattern.compile("[\\+\\-]?(?:(?:[1-9]\\d*)|(?:\\.\\d+)|(?:\\d+\\.\\d+))");

    private double exp1(){
        double ret = 0;
        if(numRegExp.matcher(token).matches()){
            if(isInteger(token)){
                ret = parseInteger(token);
            }else if(isDecimal(token)){
                ret = parseDecimal(token);
            }
            readToken();
        }else if(accept("(")){
            ret = exp2();
            expect(")");
        }else{
            System.err.printf("Unexpected token \"%s\"\n",token);
            System.exit(1);
        }
        return ret;
    }

    private double exp2(){
        double ret = 0;
        if(accept("*")){
            ret = 1;
            while(peek(")") == false){
                ret = ret * exp1();;
            }
        }else if(accept("/")){
            ret = exp1();
            if(peek(")") == false){
                while(peek(")") == false){
                  ret = ret / exp1();;
                }
            }else{
                ret = 1/ ret;
            }
        }else if(accept("+")){
            ret = 0;
            while(peek(")") == false){
                ret = ret + exp1();;
            }
        }else if(accept("-")){
            ret = 0;
            while(peek(")") == false){
                ret = ret - exp1();;
            }
        }else{
            System.err.printf("operator token expected ,actual token %s.\n",token);
            System.exit(1);
        }
        return ret;
    }


    public static void main(String[] args){
        debug = true;
        LispCalculator cal = new LispCalculator();
        if(args.length == 0){
            System.out.println("Usage : java LispCalculator (+ 3 22)");
            System.exit(1);
        }
        System.out.println(cal.eval(args[0]));
    }
}

Common Lisp入门笔记(一)7个基本运算符

表达式实例: >(+ 1 2) >3 Common Lisp表达式求值规则是: 首先对每个参数从左到右进行求值; 其次将这些已经求值的参数作为运算符函数的参数进行函数调用求值; 所求得的值作为表达式的...
  • zhutulang
  • zhutulang
  • 2016年05月08日 18:13
  • 2646

56种语言编写一个Lisp解释器

mal是一个受Clojure启发的Lisp解释器,使用到了56种语言,其每一次的实现都会被分割成11个独立的步骤。...
  • tangxiaoyin
  • tangxiaoyin
  • 2016年06月30日 12:46
  • 14016

CommonLisp(三)---高阶函数与匿名函数(lambda演算)

我一直坚信,简单为美,如果一个概念不能够用数学或者简单的形式描述,那么其可用性就不能保证。 一.高阶函数 简而言之,使用函数作为参数的函数就是高阶函数。 如果在较高的层面上抽象,函数也是数据...
  • u012711847
  • u012711847
  • 2013年12月15日 20:08
  • 1178

Google Common Lisp Style Guide.pdf

  • 2012年12月15日 07:31
  • 874KB
  • 下载

Lisp programming style and coding efficiency

+
  • perfectlife_2009
  • perfectlife_2009
  • 2016年09月24日 11:47
  • 140

Common Lisp Style Guide

ref:Common Lisp Style Guide - Ariel Networks Labs Package One package per one file Strang...
  • Proteas
  • Proteas
  • 2012年08月02日 11:18
  • 565

简单LISP表达计算器

  • 2007年09月25日 18:13
  • 6KB
  • 下载

LISP算术表达式计算器

  • 2010年06月10日 15:13
  • 237KB
  • 下载

数据结构实验---LISP简易计算器

  • 2011年06月30日 00:09
  • 6KB
  • 下载

简单LISP算术表达式计算器

  • 2011年05月30日 23:32
  • 1.82MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:献上lisp-style计算器
举报原因:
原因补充:

(最多只允许输入30个字)