← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/weka/oneiric

« back to all changes in this revision

Viewing changes to .pc/java_cup.patch/src/main/java/weka/filters/unsupervised/instance/subsetbyexpression/Scanner.jflex

  • Committer: Bazaar Package Importer
  • Author(s): Soeren Sonnenburg
  • Date: 2010-04-23 22:33:11 UTC
  • Revision ID: james.westby@ubuntu.com-20100423223311-ctmj7n1pqeppqy2a
Tags: 3.6.0-3
* Bump Standards-Version to 3.8.4 (no changes required).
* Switch to dpkg-source 3.0 (quilt) format.
* Track only stable releases in watch file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/java_cup.patch/src/main/java/weka/filters/unsupervised/instance/subsetbyexpression/Scanner.jflex
 
1
/*
 
2
 *    This program is free software; you can redistribute it and/or modify
 
3
 *    it under the terms of the GNU General Public License as published by
 
4
 *    the Free Software Foundation; either version 2 of the License, or
 
5
 *    (at your option) any later version.
 
6
 *
 
7
 *    This program is distributed in the hope that it will be useful,
 
8
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
 *    GNU General Public License for more details.
 
11
 *
 
12
 *    You should have received a copy of the GNU General Public License
 
13
 *    along with this program; if not, write to the Free Software
 
14
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
15
 */
 
16
 
 
17
/*
 
18
 * Scanner.java
 
19
 * Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
 
20
 */
 
21
 
 
22
package weka.filters.unsupervised.instance.subsetbyexpression;
 
23
 
 
24
import weka.core.parser.java_cup.runtime.SymbolFactory;
 
25
import java.io.*;
 
26
 
 
27
/**
 
28
 * A scanner for evaluating whether an Instance is to be included in a subset
 
29
 * or not.
 
30
 *
 
31
 * @author FracPete (fracpete at waikato dot ac dot nz)
 
32
 * @version $Revision: 1.2 $
 
33
 */
 
34
%%
 
35
%unicode
 
36
%char
 
37
%cup
 
38
%public
 
39
%class Scanner
 
40
%{
 
41
  // Author: FracPete (fracpete at waikato dot ac dot nz)
 
42
  // Version: $Revision: 1.2 $
 
43
  protected SymbolFactory m_SymFactory;
 
44
 
 
45
  protected StringBuffer m_String = new StringBuffer();
 
46
 
 
47
  public Scanner(InputStream r, SymbolFactory sf) {
 
48
    this(r);
 
49
    m_SymFactory = sf;
 
50
  }
 
51
%}
 
52
%eofval{
 
53
    return m_SymFactory.newSymbol("EOF",sym.EOF);
 
54
%eofval}
 
55
 
 
56
%state STRING
 
57
 
 
58
%%
 
59
<YYINITIAL> {
 
60
  // operands
 
61
  "-" { return m_SymFactory.newSymbol("Minus", sym.MINUS); }
 
62
  "+" { return m_SymFactory.newSymbol("Plus", sym.PLUS); }
 
63
  "*" { return m_SymFactory.newSymbol("Times", sym.TIMES); }
 
64
  "/" { return m_SymFactory.newSymbol("Division", sym.DIVISION); }
 
65
 
 
66
  // boolean stuff
 
67
  "<" { return m_SymFactory.newSymbol("Less than", sym.LT); }
 
68
  "<=" { return m_SymFactory.newSymbol("Less or equal than", sym.LE); }
 
69
  ">" { return m_SymFactory.newSymbol("Greater than", sym.GT); }
 
70
  ">=" { return m_SymFactory.newSymbol("Greater or equal than", sym.GE); }
 
71
  "=" { return m_SymFactory.newSymbol("Equals", sym.EQ); }
 
72
  "is" { return m_SymFactory.newSymbol("Is", sym.IS); }
 
73
  "not" { return m_SymFactory.newSymbol("Not", sym.NOT); }
 
74
  "and" { return m_SymFactory.newSymbol("And", sym.AND); }
 
75
  "or" { return m_SymFactory.newSymbol("Or", sym.OR); }
 
76
  "true" { return m_SymFactory.newSymbol("True", sym.TRUE); }
 
77
  "false" { return m_SymFactory.newSymbol("False", sym.FALSE); }
 
78
 
 
79
  // functions
 
80
  "abs" { return m_SymFactory.newSymbol("Abs", sym.ABS); }
 
81
  "sqrt" { return m_SymFactory.newSymbol("Sqrt", sym.SQRT); }
 
82
  "log" { return m_SymFactory.newSymbol("Log", sym.LOG); }
 
83
  "exp" { return m_SymFactory.newSymbol("Exp", sym.EXP); }
 
84
  "sin" { return m_SymFactory.newSymbol("Sin", sym.SIN); }
 
85
  "cos" { return m_SymFactory.newSymbol("Cos", sym.COS); }
 
86
  "tan" { return m_SymFactory.newSymbol("Tan", sym.TAN); }
 
87
  "rint" { return m_SymFactory.newSymbol("Rint", sym.RINT); }
 
88
  "floor" { return m_SymFactory.newSymbol("Floor", sym.FLOOR); }
 
89
  "pow" { return m_SymFactory.newSymbol("Pow", sym.POW); }
 
90
  "ceil" { return m_SymFactory.newSymbol("Ceil", sym.CEIL); }
 
91
 
 
92
  // numbers and variables
 
93
  "'" { yybegin(STRING); m_String.setLength(0); }
 
94
  [0-9][0-9]*\.?[0-9]* { return m_SymFactory.newSymbol("Number", sym.NUMBER, new Double(yytext())); }
 
95
  -[0-9][0-9]*\.?[0-9]* { return m_SymFactory.newSymbol("Number", sym.NUMBER, new Double(yytext())); }
 
96
  [A][T][T][0-9][0-9]* { return m_SymFactory.newSymbol("Attribute", sym.ATTRIBUTE, new String(yytext())); }
 
97
  "CLASS" { return m_SymFactory.newSymbol("Class", sym.ATTRIBUTE, new String(yytext())); }
 
98
 
 
99
  // whitespaces
 
100
  [ \r\n\t\f] { /* ignore white space. */ }
 
101
 
 
102
  // various
 
103
  "," { return m_SymFactory.newSymbol("Comma", sym.COMMA); }
 
104
  "(" { return m_SymFactory.newSymbol("Left Bracket", sym.LPAREN); }
 
105
  ")" { return m_SymFactory.newSymbol("Right Bracket", sym.RPAREN); }
 
106
  "ismissing" { return m_SymFactory.newSymbol("Missing", sym.ISMISSING); }
 
107
}
 
108
 
 
109
<STRING> {
 
110
  "'" { yybegin(YYINITIAL); return m_SymFactory.newSymbol("String", sym.STRING, new String(m_String.toString())); }
 
111
  . { m_String.append(yytext()); }
 
112
}
 
113
 
 
114
// catch all
 
115
. { System.err.println("Illegal character: " + yytext()); }