![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jsscan.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / include / mozilla / js|
Return to jsscan.h CVS log | Up to [Synchronet] / sbbs / include / mozilla / js |
1.1 root 1: /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2: *
3: * ***** BEGIN LICENSE BLOCK *****
4: * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5: *
6: * The contents of this file are subject to the Mozilla Public License Version
7: * 1.1 (the "License"); you may not use this file except in compliance with
8: * the License. You may obtain a copy of the License at
9: * http://www.mozilla.org/MPL/
10: *
11: * Software distributed under the License is distributed on an "AS IS" basis,
12: * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13: * for the specific language governing rights and limitations under the
14: * License.
15: *
16: * The Original Code is Mozilla Communicator client code, released
17: * March 31, 1998.
18: *
19: * The Initial Developer of the Original Code is
20: * Netscape Communications Corporation.
21: * Portions created by the Initial Developer are Copyright (C) 1998
22: * the Initial Developer. All Rights Reserved.
23: *
24: * Contributor(s):
25: *
26: * Alternatively, the contents of this file may be used under the terms of
27: * either of the GNU General Public License Version 2 or later (the "GPL"),
28: * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
29: * in which case the provisions of the GPL or the LGPL are applicable instead
30: * of those above. If you wish to allow use of your version of this file only
31: * under the terms of either the GPL or the LGPL, and not to allow others to
32: * use your version of this file under the terms of the MPL, indicate your
33: * decision by deleting the provisions above and replace them with the notice
34: * and other provisions required by the GPL or the LGPL. If you do not delete
35: * the provisions above, a recipient may use your version of this file under
36: * the terms of any one of the MPL, the GPL or the LGPL.
37: *
38: * ***** END LICENSE BLOCK ***** */
39:
40: #ifndef jsscan_h___
41: #define jsscan_h___
42: /*
43: * JS lexical scanner interface.
44: */
45: #include <stddef.h>
46: #include <stdio.h>
47: #include "jsopcode.h"
48: #include "jsprvtd.h"
49: #include "jspubtd.h"
50:
51: JS_BEGIN_EXTERN_C
52:
53: typedef enum JSTokenType {
54: TOK_ERROR = -1, /* well-known as the only code < EOF */
55: TOK_EOF = 0, /* end of file */
56: TOK_EOL = 1, /* end of line */
57: TOK_SEMI = 2, /* semicolon */
58: TOK_COMMA = 3, /* comma operator */
59: TOK_ASSIGN = 4, /* assignment ops (= += -= etc.) */
60: TOK_HOOK = 5, TOK_COLON = 6, /* conditional (?:) */
61: TOK_OR = 7, /* logical or (||) */
62: TOK_AND = 8, /* logical and (&&) */
63: TOK_BITOR = 9, /* bitwise-or (|) */
64: TOK_BITXOR = 10, /* bitwise-xor (^) */
65: TOK_BITAND = 11, /* bitwise-and (&) */
66: TOK_EQOP = 12, /* equality ops (== !=) */
67: TOK_RELOP = 13, /* relational ops (< <= > >=) */
68: TOK_SHOP = 14, /* shift ops (<< >> >>>) */
69: TOK_PLUS = 15, /* plus */
70: TOK_MINUS = 16, /* minus */
71: TOK_STAR = 17, TOK_DIVOP = 18, /* multiply/divide ops (* / %) */
72: TOK_UNARYOP = 19, /* unary prefix operator */
73: TOK_INC = 20, TOK_DEC = 21, /* increment/decrement (++ --) */
74: TOK_DOT = 22, /* member operator (.) */
75: TOK_LB = 23, TOK_RB = 24, /* left and right brackets */
76: TOK_LC = 25, TOK_RC = 26, /* left and right curlies (braces) */
77: TOK_LP = 27, TOK_RP = 28, /* left and right parentheses */
78: TOK_NAME = 29, /* identifier */
79: TOK_NUMBER = 30, /* numeric constant */
80: TOK_STRING = 31, /* string constant */
81: TOK_OBJECT = 32, /* RegExp or other object constant */
82: TOK_PRIMARY = 33, /* true, false, null, this, super */
83: TOK_FUNCTION = 34, /* function keyword */
84: TOK_EXPORT = 35, /* export keyword */
85: TOK_IMPORT = 36, /* import keyword */
86: TOK_IF = 37, /* if keyword */
87: TOK_ELSE = 38, /* else keyword */
88: TOK_SWITCH = 39, /* switch keyword */
89: TOK_CASE = 40, /* case keyword */
90: TOK_DEFAULT = 41, /* default keyword */
91: TOK_WHILE = 42, /* while keyword */
92: TOK_DO = 43, /* do keyword */
93: TOK_FOR = 44, /* for keyword */
94: TOK_BREAK = 45, /* break keyword */
95: TOK_CONTINUE = 46, /* continue keyword */
96: TOK_IN = 47, /* in keyword */
97: TOK_VAR = 48, /* var keyword */
98: TOK_WITH = 49, /* with keyword */
99: TOK_RETURN = 50, /* return keyword */
100: TOK_NEW = 51, /* new keyword */
101: TOK_DELETE = 52, /* delete keyword */
102: TOK_DEFSHARP = 53, /* #n= for object/array initializers */
103: TOK_USESHARP = 54, /* #n# for object/array initializers */
104: TOK_TRY = 55, /* try keyword */
105: TOK_CATCH = 56, /* catch keyword */
106: TOK_FINALLY = 57, /* finally keyword */
107: TOK_THROW = 58, /* throw keyword */
108: TOK_INSTANCEOF = 59, /* instanceof keyword */
109: TOK_DEBUGGER = 60, /* debugger keyword */
110: TOK_RESERVED, /* reserved keywords */
111: TOK_LIMIT /* domain size */
112: } JSTokenType;
113:
114: #define IS_PRIMARY_TOKEN(tt) \
115: ((uintN)((tt) - TOK_NAME) <= (uintN)(TOK_PRIMARY - TOK_NAME))
116:
117: struct JSTokenPtr {
118: uint16 index; /* index of char in physical line */
119: uint16 lineno; /* physical line number */
120: };
121:
122: struct JSTokenPos {
123: JSTokenPtr begin; /* first character and line of token */
124: JSTokenPtr end; /* index 1 past last char, last line */
125: };
126:
127: struct JSToken {
128: JSTokenType type; /* char value or above enumerator */
129: JSTokenPos pos; /* token position in file */
130: jschar *ptr; /* beginning of token in line buffer */
131: union {
132: struct {
133: JSOp op; /* operator, for minimal parser */
134: JSAtom *atom; /* atom table entry */
135: } s;
136: jsdouble dval; /* floating point number */
137: } u;
138: };
139:
140: #define t_op u.s.op
141: #define t_atom u.s.atom
142: #define t_dval u.dval
143:
144: typedef struct JSTokenBuf {
145: jschar *base; /* base of line or stream buffer */
146: jschar *limit; /* limit for quick bounds check */
147: jschar *ptr; /* next char to get, or slot to use */
148: } JSTokenBuf;
149:
150: #define JS_LINE_LIMIT 256 /* logical line buffer size limit --
151: physical line length is unlimited */
152: #define NTOKENS 4 /* 1 current + 2 lookahead, rounded */
153: #define NTOKENS_MASK (NTOKENS-1) /* to power of 2 to avoid divmod by 3 */
154:
155: struct JSTokenStream {
156: JSToken tokens[NTOKENS];/* circular token buffer */
157: uintN cursor; /* index of last parsed token */
158: uintN lookahead; /* count of lookahead tokens */
159: uintN lineno; /* current line number */
160: uintN ungetpos; /* next free char slot in ungetbuf */
161: jschar ungetbuf[6]; /* at most 6, for \uXXXX lookahead */
162: uintN flags; /* flags -- see below */
163: ptrdiff_t linelen; /* physical linebuf segment length */
164: ptrdiff_t linepos; /* linebuf offset in physical line */
165: JSTokenBuf linebuf; /* line buffer for diagnostics */
166: JSTokenBuf userbuf; /* user input buffer if !file */
167: JSTokenBuf tokenbuf; /* current token string buffer */
168: const char *filename; /* input filename or null */
169: FILE *file; /* stdio stream if reading from file */
170: JSPrincipals *principals; /* principals associated with source */
171: JSSourceHandler listener; /* callback for source; eg debugger */
172: void *listenerData; /* listener 'this' data */
173: void *listenerTSData;/* listener data for this TokenStream */
174: jschar *saveEOL; /* save next end of line in userbuf, to
175: optimize for very long lines */
176: };
177:
178: #define CURRENT_TOKEN(ts) ((ts)->tokens[(ts)->cursor])
179: #define ON_CURRENT_LINE(ts,pos) ((uint16)(ts)->lineno == (pos).end.lineno)
180:
181: /* JSTokenStream flags */
182: #define TSF_ERROR 0x01 /* fatal error while compiling */
183: #define TSF_EOF 0x02 /* hit end of file */
184: #define TSF_NEWLINES 0x04 /* tokenize newlines */
185: #define TSF_OPERAND 0x08 /* looking for operand, not operator */
186: #define TSF_NLFLAG 0x20 /* last linebuf ended with \n */
187: #define TSF_CRFLAG 0x40 /* linebuf would have ended with \r */
188: #define TSF_DIRTYLINE 0x80 /* non-whitespace since start of line */
189: #define TSF_OWNFILENAME 0x100 /* ts->filename is malloc'd */
190:
191: /* Unicode separators that are treated as line terminators, in addition to \n, \r */
192: #define LINE_SEPARATOR 0x2028
193: #define PARA_SEPARATOR 0x2029
194:
195: /*
196: * Create a new token stream, either from an input buffer or from a file.
197: * Return null on file-open or memory-allocation failure.
198: *
199: * NB: All of js_New{,Buffer,File}TokenStream() return a pointer to transient
200: * memory in the current context's temp pool. This memory is deallocated via
201: * JS_ARENA_RELEASE() after parsing is finished.
202: */
203: extern JSTokenStream *
204: js_NewTokenStream(JSContext *cx, const jschar *base, size_t length,
205: const char *filename, uintN lineno, JSPrincipals *principals);
206:
207: extern JS_FRIEND_API(JSTokenStream *)
208: js_NewBufferTokenStream(JSContext *cx, const jschar *base, size_t length);
209:
210: extern JS_FRIEND_API(JSTokenStream *)
211: js_NewFileTokenStream(JSContext *cx, const char *filename, FILE *defaultfp);
212:
213: extern JS_FRIEND_API(JSBool)
214: js_CloseTokenStream(JSContext *cx, JSTokenStream *ts);
215:
216: /*
217: * Initialize the scanner, installing JS keywords into cx's global scope.
218: */
219: extern JSBool
220: js_InitScanner(JSContext *cx);
221:
222: /*
223: * Friend-exported API entry point to call a mapping function on each reserved
224: * identifier in the scanner's keyword table.
225: */
226: extern JS_FRIEND_API(void)
227: js_MapKeywords(void (*mapfun)(const char *));
228:
229: /*
230: * Report a compile-time error by its number, using ts or cg to show context.
231: * Return true for a warning, false for an error.
232: */
233: extern JSBool
234: js_ReportCompileErrorNumber(JSContext *cx, JSTokenStream *ts,
235: JSCodeGenerator *cg, uintN flags,
236: const uintN errorNumber, ...);
237:
238: /*
239: * Look ahead one token and return its type.
240: */
241: extern JSTokenType
242: js_PeekToken(JSContext *cx, JSTokenStream *ts);
243:
244: extern JSTokenType
245: js_PeekTokenSameLine(JSContext *cx, JSTokenStream *ts);
246:
247: /*
248: * Get the next token from ts.
249: */
250: extern JSTokenType
251: js_GetToken(JSContext *cx, JSTokenStream *ts);
252:
253: /*
254: * Push back the last scanned token onto ts.
255: */
256: extern void
257: js_UngetToken(JSTokenStream *ts);
258:
259: /*
260: * Get the next token from ts if its type is tt.
261: */
262: extern JSBool
263: js_MatchToken(JSContext *cx, JSTokenStream *ts, JSTokenType tt);
264:
265: JS_END_EXTERN_C
266:
267: #endif /* jsscan_h___ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.