[求助]两个JAVA编程题目

Question

朋友问我的两个题目，本人JAVA基础太差，一直未能得到解决，在此求助各位大侠，为我提供编程的思路，如果有参考的程序或者注释，本人更加感激……
1，读取一个JAVA源程序，并且词法分析，从左到逐个字符扫描源程序，一个一个拼出单词，在拼单词的过程中做词法检查，在拼完单词是将所拼的单词翻译成相应的机内码。
2、：从一个文件中读取公式，计算每一个公式的结果并输出（注意公式中有变量，则首先提示输入变量的值）

Answer 1

...好有难度啊,不过就是很复杂,其实东西都差不多.
先以流的形式读JAVA文件,然后reader内容,然后就是判断循环判断,其实就是看你自己的逻辑思维能力了,上下两个问题都没什么区别

Answer 2

第一个问题你去jude官方网站看看，那个是做uml图的工具，开源，我没看过源码，但是他有扫描源码的部分

Answer 3

是可以用ECLIPES，我也在学习它我觉得还不错啊，，，，，，，，，，，，，，，

Answer 4

MS 架构的ScriptControl组件可实现，不妨考虑用JNI调用

Answer 5

只要懂点的人，一看就知道楼主是想用JAVA写一个编译器。

Answer 6

 编译原理的课程设计，大学里很多都做的。就是做一个编译器，转机内码的那一部份不是用汇编写的吗？怎么
是用java的啊？是不是没听清楚要求

Answer 7

http://www.wosign.com/Products/java_code_signing.htm

Answer 8

还是比较容易得,在编译原理里就有自动机,
把输入得当成一个一个得字母,适当的分割,做判断,这样就解析出语法。
假设做一个C语言一样的,只要分析词法对啦就可以。
我以前用做个java版的和C语言版的。在www.pudn.com上就有很多编译原理的列子。
自己可以搜一下。我的好像也有

Answer 9

第一题,需要编译原理知识
或者你可以看看antlr很好得工具,容易上手,前提是具有编译原理只是

Answer 10

很难很复杂 不过也不是不能解决第2题首先是读取文件的问题  就是流的问题 然后就知道你的公式了 把需要输入的变量  存储了  
把运算符+-*/等等  存储了
判断等号  等号后边估计就是一个变量或者问号   基本思想就是一个字符一个字符判断
我很久以前用pascal开发过一元一次方程的求结果问题   大概思想差不多吧  也许差很多

Answer 11

当然，第二题要看你的公式是否复杂。而且两道题必须要定义规则才能实现。
比如我们现在做的一个，
rule: (days/(sum(param1, param2))*ema(params)+1/(sum(param1, param2))*close(params)其中days代表一个数字， sum、ema、sum和close都是一个定义好的方法，
需要解析这个表达式并计算结果。

Answer 12

状态机，或者用Interceptor模式

Answer 13

import java.io.*;public class Test_Lexical {
public static void main(String[] args) throws IOException {
//读文件以及用StreamTokenizer分解文件,args[0]要求在执行的时候输入要打开的文件
/**
 * InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String filepath = br.readLine();
File inputFile = new File(filepath);
 */
File inputfile = new File(args[0]);
FileReader in = new FileReader(inputfile);
StreamTokenizer parser = new StreamTokenizer(in);
parser.ordinaryChar('\'');
parser.ordinaryChar('"');
parser.ordinaryChar('.');
parser.ordinaryChar(','); while (parser.nextToken() != StreamTokenizer.TT_EOF) {
//判断读到的Token是否为parser.sval（WORD）
if (parser.ttype == StreamTokenizer.TT_WORD) {
checkWord(parser.sval);
System.out.println(checkWord(parser.sval) + parser.sval);
}
//判断读到的Token是否为parser.nval（NUMBER） 
else if (parser.ttype == StreamTokenizer.TT_NUMBER) {
System.out.println("Number: " + parser.nval);
}
else
System.out.println("Other: " + (char)parser.ttype);
}
in.close();
} private static String checkWord(String word) {
//检查读到的Token是KeyWord、Type还是String
String key[] = { "auto", "break", "case", "char", "const", "continue",
"default", "do", "else", "enum", "extern", "for", "goto", "if",
"register", "return", "signed", "sizeof", "static", "struct",
"switch", "typedef", "union", "unsigned", "void", "volatile",
"while", "then", "else" };
String type[] = { "int", "long", "double", "float", "short", "char",
"String" }; for (int i = 0; i < 29; i++) {
if (word.equals(key[i]))
return "KeyWord: ";
}
for (int i = 0; i < 7; i++) {
if (word.equals(type[i]))
return "Type: ";
}
return "String: ";
}
}第一问的，编译原理实习吧。
你可以稍微改进一下，判断有下划线的变量不好用

Answer 14

public class OPNode { 
char op;// 运算符号 
int level;// 优先级 
//设置优先级 
public OPNode(String op) { 
this.op = op.charAt(0); 
if (op.equals("+") || op.equals("-")) { 
this.level = 1; 
} else if (op.equals("*") || op.equals("/")) { 
this.level = 2; 
} else if (op.equals("(")) { 
this.level = -3; } else { 
this.level = -1; 
} 
} 
} 
//主类 
import java.util.Deque; 
import java.util.LinkedList; 
import java.util.List; 
import java.util.regex.Matcher; 
import java.util.regex.Pattern; public class OPText { 
public static void main(String[] args) { 
String expression = "2+2+(8-2)/3";// 要计算的表达式 
List list = new LinkedList(); 
//正则式 
Pattern entryOfExpression = Pattern 
.compile("[0-9]+(\\.[0-9]+)?|\\(|\\)|\\+|-|\\*|/"); 
Deque stack = new LinkedList();//栈 
Matcher m = entryOfExpression.matcher(expression); 
while (m.find()) { 
//提取语素 
String nodeString = expression.substring(m.start(), m.end()); 
if (nodeString.matches("[0-9].*")) { 
list.add(Double.valueOf(nodeString));//如果是数字直接送入列表 
} else { 
OPNode opn = new OPNode(nodeString);//如果是运算符 
int peekLevel = (stack.peek() == null) ? 0 : ((OPNode) stack 
.peek()).level; 
if (opn.level >=peekLevel) { 
stack.push(opn);//新的运算符比旧的优先级别高则入栈 
} else { 
if (opn.level == -1) { 
OPNode temp = (OPNode) stack.pop(); 
while (temp.level != -3) {//如果为"("则一直出栈一直到")" 
list.add(temp); 
System.out.println(nodeString); 
temp = (OPNode) stack.pop(); 
} 
} else if (opn.level == -3) { 
stack.push(opn); 
} else {//如果新运算符比栈顶运算符底则一直出栈 
OPNode temp = (OPNode) stack.pop(); 
while (temp.level > opn.level) { 
list.add(temp); 
if (stack.isEmpty()) { 
break; 
} 
temp = (OPNode) stack.pop(); 
} 
stack.push(opn); 
} 
} 
} } 
OPNode temp = null; 
while (!stack.isEmpty()) { 
temp = (OPNode) stack.pop(); 
list.add(temp); 
}//后续表达式计算 
stack.clear(); 
for (Object o : list) { 
if (o instanceof Double) { 
stack.push(o);//为数字入栈 
} else { 
double op2 = ((Double) stack.pop()).doubleValue(); 
double op1 = ((Double) stack.pop()).doubleValue(); 
switch (((OPNode) o).op) { 
case '+': 
stack.push(op1 + op2); 
break; 
case '-': 
stack.push(op1 - op2); 
break; case '*': 
stack.push(op1 * op2); 
break; case '/': 
stack.push(op1 / op2); 
break; 
} } 
} 
System.out.println("结果为:" + stack.pop()); 
} }第二题的一个解法，大家有什么修改意见吗？？