src/dom/js/jsscan.h

   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_XMLSTAGO = 61,                  /* XML start tag open (<) */
 111     TOK_XMLETAGO = 62,                  /* XML end tag open (</) */
 112     TOK_XMLPTAGC = 63,                  /* XML point tag close (/>) */
 113     TOK_XMLTAGC = 64,                   /* XML start or end tag close (>) */
 114     TOK_XMLNAME = 65,                   /* XML start-tag non-final fragment */
 115     TOK_XMLATTR = 66,                   /* XML quoted attribute value */
 116     TOK_XMLSPACE = 67,                  /* XML whitespace */
 117     TOK_XMLTEXT = 68,                   /* XML text */
 118     TOK_XMLCOMMENT = 69,                /* XML comment */
 119     TOK_XMLCDATA = 70,                  /* XML CDATA section */
 120     TOK_XMLPI = 71,                     /* XML processing instruction */
 121     TOK_AT = 72,                        /* XML attribute op (@) */
 122     TOK_DBLCOLON = 73,                  /* namespace qualified name op (::) */
 123     TOK_ANYNAME = 74,                   /* XML AnyName singleton (*) */
 124     TOK_DBLDOT = 75,                    /* XML descendant op (..) */
 125     TOK_FILTER = 76,                    /* XML filtering predicate op (.()) */
 126     TOK_XMLELEM = 77,                   /* XML element node type (no token) */
 127     TOK_XMLLIST = 78,                   /* XML list node type (no token) */
 128     TOK_RESERVED,                       /* reserved keywords */
 129     TOK_LIMIT                           /* domain size */
 130 } JSTokenType;
 131
 132 #define IS_PRIMARY_TOKEN(tt) \
 133     ((uintN)((tt) - TOK_NAME) <= (uintN)(TOK_PRIMARY - TOK_NAME))
 134
 135 #define TOKEN_TYPE_IS_XML(tt) \
 136     (tt == TOK_AT || tt == TOK_DBLCOLON || tt == TOK_ANYNAME)
 137
 138 struct JSStringBuffer {
 139     jschar      *base;
 140     jschar      *limit;         /* length limit for quick bounds check */
 141     jschar      *ptr;           /* slot for next non-NUL char to store */
 142     void        *data;
 143     JSBool      (*grow)(JSStringBuffer *sb, size_t newlength);
 144     void        (*free)(JSStringBuffer *sb);
 145 };
 146
 147 #define STRING_BUFFER_ERROR_BASE        ((jschar *) 1)
 148 #define STRING_BUFFER_OK(sb)            ((sb)->base != STRING_BUFFER_ERROR_BASE)
 149 #define STRING_BUFFER_OFFSET(sb)        ((sb)->ptr -(sb)->base)
 150
 151 extern void
 152 js_InitStringBuffer(JSStringBuffer *sb);
 153
 154 extern void
 155 js_FinishStringBuffer(JSStringBuffer *sb);
 156
 157 extern void
 158 js_AppendChar(JSStringBuffer *sb, jschar c);
 159
 160 extern void
 161 js_RepeatChar(JSStringBuffer *sb, jschar c, uintN count);
 162
 163 extern void
 164 js_AppendCString(JSStringBuffer *sb, const char *asciiz);
 165
 166 extern void
 167 js_AppendJSString(JSStringBuffer *sb, JSString *str);
 168
 169 struct JSTokenPtr {
 170     uint16              index;          /* index of char in physical line */
 171     uint16              lineno;         /* physical line number */
 172 };
 173
 174 struct JSTokenPos {
 175     JSTokenPtr          begin;          /* first character and line of token */
 176     JSTokenPtr          end;            /* index 1 past last char, last line */
 177 };
 178
 179 struct JSToken {
 180     JSTokenType         type;           /* char value or above enumerator */
 181     JSTokenPos          pos;            /* token position in file */
 182     jschar              *ptr;           /* beginning of token in line buffer */
 183     union {
 184         struct {                        /* non-numeric literal */
 185             JSOp        op;             /* operator, for minimal parser */
 186             JSAtom      *atom;          /* atom table entry */
 187         } s;
 188         struct {                        /* atom pair, for XML PIs */
 189             JSAtom      *atom2;         /* auxiliary atom table entry */
 190             JSAtom      *atom;          /* main atom table entry */
 191         } p;
 192         jsdouble        dval;           /* floating point number */
 193     } u;
 194 };
 195
 196 #define t_op            u.s.op
 197 #define t_atom          u.s.atom
 198 #define t_atom2         u.p.atom2
 199 #define t_dval          u.dval
 200
 201 typedef struct JSTokenBuf {
 202     jschar              *base;          /* base of line or stream buffer */
 203     jschar              *limit;         /* limit for quick bounds check */
 204     jschar              *ptr;           /* next char to get, or slot to use */
 205 } JSTokenBuf;
 206
 207 #define JS_LINE_LIMIT   256             /* logical line buffer size limit --
 208                                            physical line length is unlimited */
 209 #define NTOKENS         4               /* 1 current + 2 lookahead, rounded */
 210 #define NTOKENS_MASK    (NTOKENS-1)     /* to power of 2 to avoid divmod by 3 */
 211
 212 struct JSTokenStream {
 213     JSToken             tokens[NTOKENS];/* circular token buffer */
 214     uintN               cursor;         /* index of last parsed token */
 215     uintN               lookahead;      /* count of lookahead tokens */
 216     uintN               lineno;         /* current line number */
 217     uintN               ungetpos;       /* next free char slot in ungetbuf */
 218     jschar              ungetbuf[6];    /* at most 6, for \uXXXX lookahead */
 219     uintN               flags;          /* flags -- see below */
 220     ptrdiff_t           linelen;        /* physical linebuf segment length */
 221     ptrdiff_t           linepos;        /* linebuf offset in physical line */
 222     JSTokenBuf          linebuf;        /* line buffer for diagnostics */
 223     JSTokenBuf          userbuf;        /* user input buffer if !file */
 224     JSStringBuffer      tokenbuf;       /* current token string buffer */
 225     const char          *filename;      /* input filename or null */
 226     FILE                *file;          /* stdio stream if reading from file */
 227     JSPrincipals        *principals;    /* principals associated with source */
 228     JSSourceHandler     listener;       /* callback for source; eg debugger */
 229     void                *listenerData;  /* listener 'this' data */
 230     void                *listenerTSData;/* listener data for this TokenStream */
 231     jschar              *saveEOL;       /* save next end of line in userbuf, to
 232                                            optimize for very long lines */
 233 };
 234
 235 #define CURRENT_TOKEN(ts)       ((ts)->tokens[(ts)->cursor])
 236 #define ON_CURRENT_LINE(ts,pos) ((uint16)(ts)->lineno == (pos).end.lineno)
 237
 238 /* JSTokenStream flags */
 239 #define TSF_ERROR       0x01            /* fatal error while compiling */
 240 #define TSF_EOF         0x02            /* hit end of file */
 241 #define TSF_NEWLINES    0x04            /* tokenize newlines */
 242 #define TSF_OPERAND     0x08            /* looking for operand, not operator */
 243 #define TSF_NLFLAG      0x20            /* last linebuf ended with \n */
 244 #define TSF_CRFLAG      0x40            /* linebuf would have ended with \r */
 245 #define TSF_DIRTYLINE   0x80            /* non-whitespace since start of line */
 246 #define TSF_OWNFILENAME 0x100           /* ts->filename is malloc'd */
 247 #define TSF_XMLTAGMODE  0x200           /* scanning within an XML tag in E4X */
 248 #define TSF_XMLTEXTMODE 0x400           /* scanning XMLText terminal from E4X */
 249 #define TSF_XMLONLYMODE 0x800           /* don't scan {expr} within text/tag */
 250
 251 /* Flag indicating unexpected end of input, i.e. TOK_EOF not at top-level. */
 252 #define TSF_UNEXPECTED_EOF 0x1000
 253
 254 /*
 255  * To handle the hard case of contiguous HTML comments, we want to clear the
 256  * TSF_DIRTYINPUT flag at the end of each such comment.  But we'd rather not
 257  * scan for --> within every //-style comment unless we have to.  So we set
 258  * TSF_IN_HTML_COMMENT when a <!-- is scanned as an HTML begin-comment, and
 259  * clear it (and TSF_DIRTYINPUT) when we scan --> either on a clean line, or
 260  * only if (ts->flags & TSF_IN_HTML_COMMENT), in a //-style comment.
 261  *
 262  * This still works as before given a malformed comment hiding hack such as:
 263  *
 264  *    <script>
 265  *      <!-- comment hiding hack #1
 266  *      code goes here
 267  *      // --> oops, markup for script-unaware browsers goes here!
 268  *    </script>
 269  *
 270  * It does not cope with malformed comment hiding hacks where --> is hidden
 271  * by C-style comments, or on a dirty line.  Such cases are already broken.
 272  */
 273 #define TSF_IN_HTML_COMMENT 0x2000
 274
 275 /* Unicode separators that are treated as line terminators, in addition to \n, \r */
 276 #define LINE_SEPARATOR  0x2028
 277 #define PARA_SEPARATOR  0x2029
 278
 279 /*
 280  * Create a new token stream, either from an input buffer or from a file.
 281  * Return null on file-open or memory-allocation failure.
 282  *
 283  * NB: All of js_New{,Buffer,File}TokenStream() return a pointer to transient
 284  * memory in the current context's temp pool.  This memory is deallocated via
 285  * JS_ARENA_RELEASE() after parsing is finished.
 286  */
 287 extern JSTokenStream *
 288 js_NewTokenStream(JSContext *cx, const jschar *base, size_t length,
 289                   const char *filename, uintN lineno, JSPrincipals *principals);
 290
 291 extern JS_FRIEND_API(JSTokenStream *)
 292 js_NewBufferTokenStream(JSContext *cx, const jschar *base, size_t length);
 293
 294 extern JS_FRIEND_API(JSTokenStream *)
 295 js_NewFileTokenStream(JSContext *cx, const char *filename, FILE *defaultfp);
 296
 297 extern JS_FRIEND_API(JSBool)
 298 js_CloseTokenStream(JSContext *cx, JSTokenStream *ts);
 299
 300 extern JS_FRIEND_API(int)
 301 js_fgets(char *buf, int size, FILE *file);
 302
 303 /*
 304  * Initialize the scanner, installing JS keywords into cx's global scope.
 305  */
 306 extern JSBool
 307 js_InitScanner(JSContext *cx);
 308
 309 /*
 310  * Friend-exported API entry point to call a mapping function on each reserved
 311  * identifier in the scanner's keyword table.
 312  */
 313 extern JS_FRIEND_API(void)
 314 js_MapKeywords(void (*mapfun)(const char *));
 315
 316 /*
 317  * Report a compile-time error by its number, using ts or cg to show context.
 318  * Return true for a warning, false for an error.
 319  */
 320 extern JSBool
 321 js_ReportCompileErrorNumber(JSContext *cx, void *handle, uintN flags,
 322                             uintN errorNumber, ...);
 323
 324 extern JSBool
 325 js_ReportCompileErrorNumberUC(JSContext *cx, void *handle, uintN flags,
 326                               uintN errorNumber, ...);
 327
 328 /* Steal some JSREPORT_* bits (see jsapi.h) to tell handle's type. */
 329 #define JSREPORT_HANDLE 0x300
 330 #define JSREPORT_TS     0x000
 331 #define JSREPORT_CG     0x100
 332 #define JSREPORT_PN     0x200
 333
 334 /*
 335  * Look ahead one token and return its type.
 336  */
 337 extern JSTokenType
 338 js_PeekToken(JSContext *cx, JSTokenStream *ts);
 339
 340 extern JSTokenType
 341 js_PeekTokenSameLine(JSContext *cx, JSTokenStream *ts);
 342
 343 /*
 344  * Get the next token from ts.
 345  */
 346 extern JSTokenType
 347 js_GetToken(JSContext *cx, JSTokenStream *ts);
 348
 349 /*
 350  * Push back the last scanned token onto ts.
 351  */
 352 extern void
 353 js_UngetToken(JSTokenStream *ts);
 354
 355 /*
 356  * Get the next token from ts if its type is tt.
 357  */
 358 extern JSBool
 359 js_MatchToken(JSContext *cx, JSTokenStream *ts, JSTokenType tt);
 360
 361 JS_END_EXTERN_C
 362
 363 #endif /* jsscan_h___ */