src/selection/Token.hpp

 /*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Acknowledgement of the program authors must be made in any
 *    publication of scientific results based in part on use of the
 *    program.  An acceptable form of acknowledgement is citation of
 *    the article in which the program was described (Matthew
 *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
 *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
 *    Parallel Simulation Engine for Molecular Dynamics,"
 *    J. Comput. Chem. 26, pp. 252-271 (2005))
 *
 * 2. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 3. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 */

#ifndef SELECTION_TOKEN_HPP
#define SELECTION_TOKEN_HPP


namespace oopse {


/**
 * @class Token
 * @todo document
 */
class Token {

    public:

        int tok;
        int intValue;
        
        const static int nada              =  0;
        const static int identifier        =  1;
        const static int integer           =  2;
        const static int decimal           =  3;
        const static int string            =  4;
        const static int seqcode           =  5;
        const static int unknown           =  6;
        const static int keyword           =  7;
        const static int whitespace        =  8;
        const static int comment           =  9;
        const static int endofline         = 10;
        const static int endofstatement    = 11;

        const static int command           = (1 <<  8);
        const static int expressionCommand = (1 <<  9); // expression command
        const static int expression        = (1 << 15); /// expression term

        // every property is also valid in an expression context
        const static int atomproperty      = (1 << 16) | expression;
        // every predefined is also valid in an expression context
        const static int comparator        = (1 << 17) | expression;
        const static int predefinedset     = (1 << 18) | expression;
        // generally, the minus sign is used to denote atom ranges
        // this property is used for the few commands which allow negative integers
        const static int negnums      = (1 << 21);
        // for some commands the 'set' is optional

        // These are unrelated
        const static int varArgCount       = (1 << 4);
        const static int onDefault1        = (1 << 5) | 1;

        // rasmol commands
        const static int define       = command | expressionCommand |1;
        const static int select       = command |expressionCommand |2 ;
        const static int all          = expression | 11 ; 

        // atom expression operators
        const static int leftparen    = expression |  0;
        const static int rightparen   = expression |  1;
        const static int hyphen       = expression |  2;
        const static int opAnd        = expression |  3;
        const static int opOr         = expression |  4;
        const static int opNot        = expression |  5;
        const static int within       = expression |  6;
        const static int plus         = expression |  7;
        const static int pick         = expression |  8;
        const static int asterisk     = expression |  9;
        const static int dot          = expression | 11;
        const static int leftsquare   = expression | 12;
        const static int rightsquare  = expression | 13;
        const static int colon        = expression | 14;
        const static int slash        = expression | 15;

        // miguel 2005 01 01
        // these are used to demark the beginning and end of expressions
        // they do not exist in the source code, but are emitted by the
        // expression compiler
        const static int expressionBegin = expression | 100;
        const static int expressionEnd   = expression | 101;

        const static int atomno       = atomproperty | 0;
        const static int elemno       = atomproperty | 1;
        const static int resno        = atomproperty | 2;
        const static int radius       = atomproperty | 3 ; 
        const static int _bondedcount = atomproperty | 6;
        const static int _groupID     = atomproperty | 7;
        const static int _atomID      = atomproperty | 8;
        const static int _structure   = atomproperty | 9;
        const static int occupancy    = atomproperty | 10;
        const static int polymerLength= atomproperty | 11;

        const static int opGT         = comparator |  0;
        const static int opGE         = comparator |  1;
        const static int opLE         = comparator |  2;
        const static int opLT         = comparator |  3;
        const static int opEQ         = comparator |  4;
        const static int opNE         = comparator |  5;
 
        const static int x            =  expression |2;
        const static int y            =  expression | 3;
        const static int z            =  expression | 4;
        const static int none      =  expression | 5;
 
 
        const static Token tokenAll(all, "all");
        const static Token tokenAnd(opAnd, "and");
        const static Token tokenElemno(elemno, "elemno");
        const static Token tokenExpressionBegin(expressionBegin, "expressionBegin");
        const static Token tokenExpressionEnd(expressionEnd, "expressionEnd");


        const static String[] comparatorNames = {">", ">=", "<=", "<", "=", "!="};
        const static String[] atomPropertyNames = {
        "atomno", "elemno", "resno", "radius", "temperature", "model",
        "_bondedcount", "_groupID", "_atomID", "_structure"};

        /*
        Note that the RasMol scripting language is case-insensitive.
        So, the compiler turns all identifiers to lower-case before
        looking up in the hash table. 
        Therefore, the left column of this array *must* be lower-case
        */

        const static Object[] arrayPairs  = {
        // commands 
        "define",            new Token(define,   varArgCount, "define"), 
        "select",            new Token(select,   varArgCount, "select"), 
        // atom expressions
        "(",            new Token(leftparen, "("),
        ")",            new Token(rightparen, ")"),
        "-",            new Token(hyphen, "-"),
        "and",          tokenAnd,
        "&",            null,
        "&&",           null,
        "or",           new Token(opOr, "or"),
        ",",            null,
        "|",            null,
        "||",            null,
        "not",          new Token(opNot, "not"),
        "!",            null,
        "<",            new Token(opLT, "<"),
        "<=",           new Token(opLE, "<="),
        ">=",           new Token(opGE, ">="),
        ">",            new Token(opGT, ">="),
        "==",           new Token(opEQ, "=="),
        "=",            null,
        "!=",           new Token(opNE, "!="),
        "<>",           null,
        "/=",           null,
        "within",       new Token(within, "within"),
        "+",            new Token(plus, "+"),
        "pick",         new Token(pick, "pick"),
        ".",            new Token(dot, "."),
        "[",            new Token(leftsquare,  "["),
        "]",            new Token(rightsquare, "]"),
        ":",            new Token(colon, ":"),
        "/",            new Token(slash, "/"),

        "atomno",       new Token(atomno, "atomno"),
        "elemno",       tokenElemno,
        "_e",           tokenElemno,
        "resno",        new Token(resno, "resno"),
        "temperature",  new Token(temperature, "temperature"),
        "relativetemperature",  null,
        "_bondedcount", new Token(_bondedcount, "_bondedcount"),
        "_groupID",     new Token(_groupID, "_groupID"),
        "_g",           null,
        "_atomID",      new Token(_atomID, "_atomID"),
        "_a",           null,
        "_structure",   new Token(_structure, "_structure"),
        "occupancy",    new Token(occupancy, "occupancy"),
        "polymerlength",new Token(polymerLength, "polymerlength"),
 
        "x",            new Token(x, "x"),
        "y",            new Token(y, "y"),
        "z",            new Token(z, "z"),
        "*",            new Token(asterisk, "*"),
        "all",          tokenAll,
        "none",         new Token(none, "none"),
 
         };


  static Hashtable map = new Hashtable();
  static {
    Token tokenLast = null;
    String stringThis;
    Token tokenThis;
    for (int i = 0; i + 1 < arrayPairs.length; i += 2) {
      stringThis = (String) arrayPairs[i];
      tokenThis = (Token) arrayPairs[i + 1];
      if (tokenThis == null)
        tokenThis = tokenLast;
      if (map.get(stringThis) != null)
        System.out.println("duplicate token definition:" + stringThis);
      map.put(stringThis, tokenThis);
      tokenLast = tokenThis;
    }
  }
  

};

}

#endif 
Revision:	1961
Committed:	Tue Feb 1 06:55:00 2005 UTC (19 years, 5 months ago) by tim
File size:	10271 byte(s)
Log Message:	adding selection library
#	Content
1	/*
2	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	*
4	* The University of Notre Dame grants you ("Licensee") a
5	* non-exclusive, royalty free, license to use, modify and
6	* redistribute this software in source and binary code form, provided
7	* that the following conditions are met:
8	*
9	* 1. Acknowledgement of the program authors must be made in any
10	* publication of scientific results based in part on use of the
11	* program. An acceptable form of acknowledgement is citation of
12	* the article in which the program was described (Matthew
13	* A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14	* J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15	* Parallel Simulation Engine for Molecular Dynamics,"
16	* J. Comput. Chem. 26, pp. 252-271 (2005))
17	*
18	* 2. Redistributions of source code must retain the above copyright
19	* notice, this list of conditions and the following disclaimer.
20	*
21	* 3. Redistributions in binary form must reproduce the above copyright
22	* notice, this list of conditions and the following disclaimer in the
23	* documentation and/or other materials provided with the
24	* distribution.
25	*
26	* This software is provided "AS IS," without a warranty of any
27	* kind. All express or implied conditions, representations and
28	* warranties, including any implied warranty of merchantability,
29	* fitness for a particular purpose or non-infringement, are hereby
30	* excluded. The University of Notre Dame and its licensors shall not
31	* be liable for any damages suffered by licensee as a result of
32	* using, modifying or distributing the software or its
33	* derivatives. In no event will the University of Notre Dame or its
34	* licensors be liable for any lost revenue, profit or data, or for
35	* direct, indirect, special, consequential, incidental or punitive
36	* damages, however caused and regardless of the theory of liability,
37	* arising out of the use of or inability to use software, even if the
38	* University of Notre Dame has been advised of the possibility of
39	* such damages.
40	*/
41
42	#ifndef SELECTION_TOKEN_HPP
43	#define SELECTION_TOKEN_HPP
44
45
46	namespace oopse {
47
48
49	/**
50	* @class Token
51	* @todo document
52	*/
53	class Token {
54
55	public:
56
57	int tok;
58	int intValue;
59
60	const static int nada = 0;
61	const static int identifier = 1;
62	const static int integer = 2;
63	const static int decimal = 3;
64	const static int string = 4;
65	const static int seqcode = 5;
66	const static int unknown = 6;
67	const static int keyword = 7;
68	const static int whitespace = 8;
69	const static int comment = 9;
70	const static int endofline = 10;
71	const static int endofstatement = 11;
72
73	const static int command = (1 << 8);
74	const static int expressionCommand = (1 << 9); // expression command
75	const static int expression = (1 << 15); /// expression term
76
77	// every property is also valid in an expression context
78	const static int atomproperty = (1 << 16) \| expression;
79	// every predefined is also valid in an expression context
80	const static int comparator = (1 << 17) \| expression;
81	const static int predefinedset = (1 << 18) \| expression;
82	// generally, the minus sign is used to denote atom ranges
83	// this property is used for the few commands which allow negative integers
84	const static int negnums = (1 << 21);
85	// for some commands the 'set' is optional
86
87	// These are unrelated
88	const static int varArgCount = (1 << 4);
89	const static int onDefault1 = (1 << 5) \| 1;
90
91	// rasmol commands
92	const static int define = command \| expressionCommand \|1;
93	const static int select = command \|expressionCommand \|2 ;
94	const static int all = expression \| 11 ;
95
96	// atom expression operators
97	const static int leftparen = expression \| 0;
98	const static int rightparen = expression \| 1;
99	const static int hyphen = expression \| 2;
100	const static int opAnd = expression \| 3;
101	const static int opOr = expression \| 4;
102	const static int opNot = expression \| 5;
103	const static int within = expression \| 6;
104	const static int plus = expression \| 7;
105	const static int pick = expression \| 8;
106	const static int asterisk = expression \| 9;
107	const static int dot = expression \| 11;
108	const static int leftsquare = expression \| 12;
109	const static int rightsquare = expression \| 13;
110	const static int colon = expression \| 14;
111	const static int slash = expression \| 15;
112
113	// miguel 2005 01 01
114	// these are used to demark the beginning and end of expressions
115	// they do not exist in the source code, but are emitted by the
116	// expression compiler
117	const static int expressionBegin = expression \| 100;
118	const static int expressionEnd = expression \| 101;
119
120	const static int atomno = atomproperty \| 0;
121	const static int elemno = atomproperty \| 1;
122	const static int resno = atomproperty \| 2;
123	const static int radius = atomproperty \| 3 ;
124	const static int _bondedcount = atomproperty \| 6;
125	const static int _groupID = atomproperty \| 7;
126	const static int _atomID = atomproperty \| 8;
127	const static int _structure = atomproperty \| 9;
128	const static int occupancy = atomproperty \| 10;
129	const static int polymerLength= atomproperty \| 11;
130
131	const static int opGT = comparator \| 0;
132	const static int opGE = comparator \| 1;
133	const static int opLE = comparator \| 2;
134	const static int opLT = comparator \| 3;
135	const static int opEQ = comparator \| 4;
136	const static int opNE = comparator \| 5;
137
138	const static int x = expression \|2;
139	const static int y = expression \| 3;
140	const static int z = expression \| 4;
141	const static int none = expression \| 5;
142
143
144	const static Token tokenAll(all, "all");
145	const static Token tokenAnd(opAnd, "and");
146	const static Token tokenElemno(elemno, "elemno");
147	const static Token tokenExpressionBegin(expressionBegin, "expressionBegin");
148	const static Token tokenExpressionEnd(expressionEnd, "expressionEnd");
149
150
151	const static String[] comparatorNames = {">", ">=", "<=", "<", "=", "!="};
152	const static String[] atomPropertyNames = {
153	"atomno", "elemno", "resno", "radius", "temperature", "model",
154	"_bondedcount", "_groupID", "_atomID", "_structure"};
155
156	/*
157	Note that the RasMol scripting language is case-insensitive.
158	So, the compiler turns all identifiers to lower-case before
159	looking up in the hash table.
160	Therefore, the left column of this array must be lower-case
161	*/
162
163	const static Object[] arrayPairs = {
164	// commands
165	"define", new Token(define, varArgCount, "define"),
166	"select", new Token(select, varArgCount, "select"),
167	// atom expressions
168	"(", new Token(leftparen, "("),
169	")", new Token(rightparen, ")"),
170	"-", new Token(hyphen, "-"),
171	"and", tokenAnd,
172	"&", null,
173	"&&", null,
174	"or", new Token(opOr, "or"),
175	",", null,
176	"\|", null,
177	"\|\|", null,
178	"not", new Token(opNot, "not"),
179	"!", null,
180	"<", new Token(opLT, "<"),
181	"<=", new Token(opLE, "<="),
182	">=", new Token(opGE, ">="),
183	">", new Token(opGT, ">="),
184	"==", new Token(opEQ, "=="),
185	"=", null,
186	"!=", new Token(opNE, "!="),
187	"<>", null,
188	"/=", null,
189	"within", new Token(within, "within"),
190	"+", new Token(plus, "+"),
191	"pick", new Token(pick, "pick"),
192	".", new Token(dot, "."),
193	"[", new Token(leftsquare, "["),
194	"]", new Token(rightsquare, "]"),
195	":", new Token(colon, ":"),
196	"/", new Token(slash, "/"),
197
198	"atomno", new Token(atomno, "atomno"),
199	"elemno", tokenElemno,
200	"_e", tokenElemno,
201	"resno", new Token(resno, "resno"),
202	"temperature", new Token(temperature, "temperature"),
203	"relativetemperature", null,
204	"_bondedcount", new Token(_bondedcount, "_bondedcount"),
205	"_groupID", new Token(_groupID, "_groupID"),
206	"_g", null,
207	"_atomID", new Token(_atomID, "_atomID"),
208	"_a", null,
209	"_structure", new Token(_structure, "_structure"),
210	"occupancy", new Token(occupancy, "occupancy"),
211	"polymerlength",new Token(polymerLength, "polymerlength"),
212
213	"x", new Token(x, "x"),
214	"y", new Token(y, "y"),
215	"z", new Token(z, "z"),
216	"", new Token(asterisk, ""),
217	"all", tokenAll,
218	"none", new Token(none, "none"),
219
220	};
221
222
223	static Hashtable map = new Hashtable();
224	static {
225	Token tokenLast = null;
226	String stringThis;
227	Token tokenThis;
228	for (int i = 0; i + 1 < arrayPairs.length; i += 2) {
229	stringThis = (String) arrayPairs[i];
230	tokenThis = (Token) arrayPairs[i + 1];
231	if (tokenThis == null)
232	tokenThis = tokenLast;
233	if (map.get(stringThis) != null)
234	System.out.println("duplicate token definition:" + stringThis);
235	map.put(stringThis, tokenThis);
236	tokenLast = tokenThis;
237	}
238	}
239
240
241	};
242
243	}
244
245	#endif