lexjava的简单介绍
今天给各位分享lexjava的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
java 怎么根据输入的公式计算结果
深圳远标为你解答这个问题
通过栈实现,先用栈将中缀表达式转化为后缀表达式，然后再用栈计算后缀表达式的值的
package com.saturday;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MyParse {
static MapString,Integer optrOrder;
static {
optrOrder=new HashMapString,Integer();
optrOrder.put("(", 0);
optrOrder.put("*", 1);
optrOrder.put("/", 1);
optrOrder.put("%", 1);
optrOrder.put("+",2);
optrOrder.put("-",2);
optrOrder.put("^",3);
optrOrder.put("#",3);
}
public static void main(String[] args){
ListString tokens;
try{
//词法分析
tokens=lex("+2* (-2+3*4)+-5");
//中缀转后缀
tokens=toRpn(tokens);
//计算结果
System.out.println(calcRpn(tokens));
}catch(Exception ex){
ex.printStackTrace();
}
}
/**
* 将输入串转换为操作符串
* @param sExpres
* @return
*/
public static ListString lex(String sExpres){
ListString tokens=new ArrayListString();
//将表达式分割成符号序列
String sRegExp="(((?=^|\\(|\\+|-|\\*|/|%)(\\+|-))?\\d+(\\.\\d+)?)"
+"|\\(|\\)|\\*|/|\\+|-";
Pattern p=Pattern.compile(sRegExp);
Matcher m=p.matcher(sExpres.replaceAll("\\s+",""));
while(m.find()){
tokens.add(m.group());
}
tokens.add("#");
return tokens;
}
/**
* 将中缀表单时转化为后缀表达式
* @param tokens
* @return
*/
public static ListString toRpn(ListString tokens)
throws Exception{
ListString rpnList=new ArrayListString();
StackString optrStack=new StackString();
optrStack.add("^");
for(String token:tokens){
if(token.matches("^(\\+|-)?\\d+(\\.\\d+)?$")){
rpnList.add(token);
}else{
outputOptr(token,optrStack,rpnList);
}
}
if(!optrStack.isEmpty()
optrStack.lastElement().equals("#")){
return rpnList;
}else{
throw new Exception("后缀表达式转化错误!");
}
}
/**
* 计算后缀表达式的值
* @param rpnTokens
* @return
* @throws Exception
*/
public static double calcRpn(ListString rpnTokens)
throws Exception{
NumberFormat nf=NumberFormat.getInstance();
StackDouble numStack=new StackDouble();
for (String token : rpnTokens) {
if (token.matches("^(\\+|-)?\\d+(.\\d+)?$")) {
token=token.indexOf('+')==0
?token.substring(1)
:token;
numStack.add(nf.parse(token).doubleValue());
} else {
doCalcByOptr(token, numStack);
}
}
if (!numStack.isEmpty() numStack.size() == 1) {
return numStack.lastElement();
} else {
throw new Exception("计算错误！");
}
}
/**
* 将运算符输出到后缀表达式序列.
* @param optr
* @param optrStack
* @param rpnList
* @throws Exception
*/
public static void outputOptr(String optr,
StackString optrStack,
ListString rpnList)
throws Exception{
String preOptr;
if(optr.equals("(")){//处理左括号
optrStack.push(optr);
return;
}
if(optr.equals(")")){//处理右括号
while(!optrStack.isEmpty()){
preOptr=optrStack.pop();
if(!preOptr.equals("(")){
rpnList.add(preOptr);
}else{
break;
}
}
if(optrStack.isEmpty()){
throw new Exception("括号未闭合!");
}
return;
}
/*按优先级处理其他运算符，若当前运算符优先级较高
* 直接入栈，否则将栈中运算符出战直至栈顶运算符
* 低于当前运算符
*/
preOptr=optrStack.lastElement();
if(optrCmp(optr,preOptr)0){
optrStack.push(optr);
}else{
while(!preOptr.equals("(")
!optrStack.isEmpty()
optrCmp(optr,preOptr)=0){
preOptr=optrStack.pop();
if(!preOptr.equals("^")){
rpnList.add(preOptr);
}
}
optrStack.push(optr);
}
}
/**
* 运算符优先级比较函数,optr1优先级大于optr2返回小于0值,
* 优先级相等返回0,optr1小于optr2返回大于0值.
* @param optr1
* @param optr2
* @return
*/
public static int optrCmp(String optr1,String optr2){
int order1=optrOrder.get(optr1);
int order2=optrOrder.get(optr2);
return order1-order2;
}
/**
* 根据运算符对数据栈中的内容进行操作.
* @param optr
* @param numStack
*/
public static void doCalcByOptr(String optr,
StackDouble numStack){
double n1,n2;
n2=numStack.pop();
n1=numStack.pop();
if(optr.equals("+")){
numStack.push(n1+n2);
}else if(optr.equals("-")){
numStack.push(n1-n2);
}else if(optr.equals("*")){
numStack.push(n1*n2);
}else if(optr.equals("/")){
numStack.push(n1/n2);
}else if(optr.equals("%")){
numStack.push(n1%n2);
}
}
}
诺基亚5230如何用xlexcdjava（移动朗文双向词典）
我用的是有道词典，这款词典的豪华版也还蛮好用的，没用过移动朗文双向词典xlexcdjava，不过理论上来说应该属点击输入单词的框框，然后自动弹出输入框来呀
lex宿主语言可以用java吗
Lex是美国Bell实验室用C语言研制的一个词法分析程序自生成工具
。它的基本原理就是使用正则表达式扫描匹配文本，并为每一个匹配模式定义一些操作，当用C语言作宿主语言时，这些操作都由C语言实现。
一种匹配的正则表达式可能会包含相关的动作。这一动作可能还包括返回一个标记。当 Lex 接收到文件或文本形式的输入时，它试图将文本与正则表达式进行匹配。它一次读入一个输入字符，直到找到一个匹配的模式。如果能够找到一个匹配的模式，Lex 就执行相关的动作（可能包括返回一个标记）。另一方面，如果没有可以匹配的正则表达式，将会停止进一步的处理，Lex 将显示一个错误消息。
Lex 和 C 是强耦合的。一个 .l 文件（Lex 文件具有 .l 的扩展名）通过 lex 公用程序来传递，并生成 C 的输出文件。这些文件被编译为词法分析器的可执行版本。
本程序对java源程序进行分析，主要实现以下两个功能：
(1)、清除注释。java源程序有三种注释方法：1、单行注释，以//开头直到行结束；2、多行注释，以/*为开始，*/为结束，可以注释多行；3、java文档注释，这也是一种多行注释，但它可以通过java文档生成工具写入java程序文档中。它以/**为开始，*/为结束。
(2)、通过程序行数计算工作量。
(3)、计算程序中类的个数，并判断有没有两个public类，如果存在则报错：There is an error:One java file cannot includes two public class。
单行注释的清除。由于单行注释以//开头直到行结束，首先要匹配的就是//，然后清除从匹配处到行结束的所有字符。具体实现如下：
"//" {
int c;
while ( (c = input()) != '/n'
c != EOF )
{
;
}
code = add(code,'/n');
}
多行注释的清除。多行注释有两种，一种是普通多行注释，另一种是java文档注释。这两种注释都以*/结束，普通多行注释以/*开始，java文档注释以/**开始。可以先匹配/*，然后向后搜索*/。要区别这两种注释就要看/*后面是否紧跟一个*字符，如果不是则为普通多行注释；如果是还要看下一字符是否为/字符，如果是也为普通注释，如果不是则为java文档注释。具体lex程序实现如下：
"/*" {
int c,ct=0;
char * javadoc = "/*there is a Java Doc Comment*/";
for ( ; ; )
{
while ( (c = input()) != '*'
c != EOF )
{
ct++;
}
if ( c == '*' )
{
c = input();
if ( c == '/' )
{
ct = 0;
break; /* found the end */
}
else
{
if(ct==0)
code = strcat(code,javadoc);
}
}
if ( c == EOF )
{
printf( "EOF in comment" );
break;
}
}
}
my.l即为lex程序。输入一段带有注释的java源程序，然后打入结束标志$号，回车就可以看到在输出的程序中所有注释都已经删除，在含有java文档注释的地方加上了一句注释：/*there is a Java Doc Comment*/。
经过仔细研究发现，上面的实现过程还是过分依赖C语言，没有真正发挥Lex模式匹配的强大功能。单行注释、普通多行注释、Java文档注释可分别由下列模式匹配：
////.*/n
///*[^/*//]*/*//
///*/*[^/*//]*/*//
本程序还提供了识别类定义的功能，匹配模式如下：
public[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/]}*/}
(public|protected|private)[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/]}*/}
[ /n/t]*class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/]}*/}
经完善后的lex程序如下所示：
%{
#include string.h
char * code = "";
int codelines = 0;
int classnum = 0;
int pubclass = 0;
char * classes[4]={"","","",""};
/*add a char c to the string code*/
char * add(char * code,char c)
{
char * temp;
if(code==NULL)
return "";
temp = (char*)malloc(sizeof(char)*2);
temp[0] = c;
temp[1] = '/0';
temp = strcat(code,temp);
return temp;
}
%}
%%
///*[^/*//]*/*// code = add(code,'');
///*/*[^/*//]*/*// code = strcat(code,"/*there is a Java Doc Comment*//n");
////.*/n code = add(code,'/n');
public[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/}]*/} {
classes[classnum] = (char*)malloc(100);
classes[classnum] = strcpy(classes[classnum],yytext);
classnum++;
code = strcat(code,yytext);
pubclass++;
}
(public|protected|private)[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/}]*/} {
classes[classnum] = (char*)malloc(100);
classes[classnum] = strcpy(classes[classnum],yytext);
classnum++;
code = strcat(code,yytext);
}
[ /n/t]*class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/}]*/} {
classes[classnum] = (char*)malloc(100);
classes[classnum] = strcpy(classes[classnum],yytext);
classnum++;
code = strcat(code,yytext);
}
/n code = add(code,'/n');
. {
if(yytext[0] == ';')
codelines++;
code = add(code,yytext[0]);
}
%%
yywrap()
{
int i=0;
printf("/nBelow is the code without comment:/n/n");
printf(code);
printf("/n/nConclude:/nThis code weights %d lines/n",codelines);
printf("This code includes %d classes/n",classnum);
printf("classes:/n");
for(i=0;iclassnum;i++)
{
printf(classes[i]);
printf("/n");
}
if(pubclass1)
printf("/nThere is an error: a java file cannot have two public class/n");
code = (char*)malloc(1);
code[0]='/0';
}
main()
{
yylex();
system("pause");
return 1;
}
这个程序还有另外两个其他功能：1、根据程序的行数来确定程序工作量，行数等于分号的个数。在结果的末尾将会显示行数；2、我们知道一个java文件中不能存在两个public类，本程序可以检查一个文件中存在几个类，并判断是否存在两个或两个以上的public类，如果存在就报错。
注：my.l文件是改进前的lex程序，改进后的程序保存在my1.l文件中，Java.txt内含有一个java源程序可以用来测试。运行lexyy.exe，复制java.txt里面的内容粘贴到程序里，加上输入结束符Ctrl+z，然后回车即可看到结果；或者在dos下把java.txt作为lexyy.exe的参数运行lexyy.exe也可。
使用CreateFile创建的文件位置很奇怪
尽量避免使用相对路径， 相对路径是从运行时的“当前”路径开始的， 从图形界面运行起来的程序的当前路径就是在文档那里
关于lexjava和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-11-28，除非注明，否则均为原创文章，转载请注明出处。