misc/liblua/lparser.c
author dag10
Mon, 21 Jan 2013 00:30:18 -0500
changeset 8415 02acf6b92f52
parent 2812 0a24853de796
child 10017 de822cd3df3a
permissions -rw-r--r--
Moved room name edit box from footer to top of page. Also shows room name when in slave mode. Temporarily increased HWForm's min height from 580 to 610.
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2812
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     1
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     2
** $Id: lparser.c,v 2.42.1.3 2007/12/28 15:32:23 roberto Exp $
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     3
** Lua Parser
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     4
** See Copyright Notice in lua.h
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     5
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     6
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     7
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     8
#include <string.h>
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
     9
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    10
#define lparser_c
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    11
#define LUA_CORE
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    12
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    13
#include "lua.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    14
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    15
#include "lcode.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    16
#include "ldebug.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    17
#include "ldo.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    18
#include "lfunc.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    19
#include "llex.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    20
#include "lmem.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    21
#include "lobject.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    22
#include "lopcodes.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    23
#include "lparser.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    24
#include "lstate.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    25
#include "lstring.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    26
#include "ltable.h"
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    27
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    28
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    29
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    30
#define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    31
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    32
#define getlocvar(fs, i)	((fs)->f->locvars[(fs)->actvar[i]])
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    33
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    34
#define luaY_checklimit(fs,v,l,m)	if ((v)>(l)) errorlimit(fs,l,m)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    35
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    36
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    37
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    38
** nodes for block list (list of active blocks)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    39
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    40
typedef struct BlockCnt {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    41
  struct BlockCnt *previous;  /* chain */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    42
  int breaklist;  /* list of jumps out of this loop */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    43
  lu_byte nactvar;  /* # active locals outside the breakable structure */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    44
  lu_byte upval;  /* true if some variable in the block is an upvalue */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    45
  lu_byte isbreakable;  /* true if `block' is a loop */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    46
} BlockCnt;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    47
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    48
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    49
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    50
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    51
** prototypes for recursive non-terminal functions
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    52
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    53
static void chunk (LexState *ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    54
static void expr (LexState *ls, expdesc *v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    55
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    56
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    57
static void anchor_token (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    58
  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    59
    TString *ts = ls->t.seminfo.ts;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    60
    luaX_newstring(ls, getstr(ts), ts->tsv.len);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    61
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    62
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    63
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    64
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    65
static void error_expected (LexState *ls, int token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    66
  luaX_syntaxerror(ls,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    67
      luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    68
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    69
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    70
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    71
static void errorlimit (FuncState *fs, int limit, const char *what) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    72
  const char *msg = (fs->f->linedefined == 0) ?
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    73
    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    74
    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    75
                            fs->f->linedefined, limit, what);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    76
  luaX_lexerror(fs->ls, msg, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    77
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    78
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    79
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    80
static int testnext (LexState *ls, int c) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    81
  if (ls->t.token == c) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    82
    luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    83
    return 1;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    84
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    85
  else return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    86
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    87
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    88
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    89
static void check (LexState *ls, int c) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    90
  if (ls->t.token != c)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    91
    error_expected(ls, c);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    92
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    93
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    94
static void checknext (LexState *ls, int c) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    95
  check(ls, c);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    96
  luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    97
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    98
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
    99
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   100
#define check_condition(ls,c,msg)	{ if (!(c)) luaX_syntaxerror(ls, msg); }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   101
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   102
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   103
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   104
static void check_match (LexState *ls, int what, int who, int where) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   105
  if (!testnext(ls, what)) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   106
    if (where == ls->linenumber)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   107
      error_expected(ls, what);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   108
    else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   109
      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   110
             LUA_QS " expected (to close " LUA_QS " at line %d)",
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   111
              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   112
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   113
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   114
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   115
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   116
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   117
static TString *str_checkname (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   118
  TString *ts;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   119
  check(ls, TK_NAME);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   120
  ts = ls->t.seminfo.ts;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   121
  luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   122
  return ts;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   123
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   124
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   125
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   126
static void init_exp (expdesc *e, expkind k, int i) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   127
  e->f = e->t = NO_JUMP;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   128
  e->k = k;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   129
  e->u.s.info = i;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   130
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   131
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   132
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   133
static void codestring (LexState *ls, expdesc *e, TString *s) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   134
  init_exp(e, VK, luaK_stringK(ls->fs, s));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   135
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   136
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   137
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   138
static void checkname(LexState *ls, expdesc *e) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   139
  codestring(ls, e, str_checkname(ls));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   140
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   141
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   142
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   143
static int registerlocalvar (LexState *ls, TString *varname) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   144
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   145
  Proto *f = fs->f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   146
  int oldsize = f->sizelocvars;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   147
  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   148
                  LocVar, SHRT_MAX, "too many local variables");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   149
  while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   150
  f->locvars[fs->nlocvars].varname = varname;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   151
  luaC_objbarrier(ls->L, f, varname);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   152
  return fs->nlocvars++;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   153
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   154
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   155
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   156
#define new_localvarliteral(ls,v,n) \
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   157
  new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   158
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   159
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   160
static void new_localvar (LexState *ls, TString *name, int n) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   161
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   162
  luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   163
  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   164
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   165
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   166
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   167
static void adjustlocalvars (LexState *ls, int nvars) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   168
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   169
  fs->nactvar = cast_byte(fs->nactvar + nvars);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   170
  for (; nvars; nvars--) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   171
    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   172
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   173
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   174
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   175
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   176
static void removevars (LexState *ls, int tolevel) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   177
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   178
  while (fs->nactvar > tolevel)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   179
    getlocvar(fs, --fs->nactvar).endpc = fs->pc;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   180
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   181
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   182
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   183
static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   184
  int i;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   185
  Proto *f = fs->f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   186
  int oldsize = f->sizeupvalues;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   187
  for (i=0; i<f->nups; i++) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   188
    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   189
      lua_assert(f->upvalues[i] == name);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   190
      return i;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   191
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   192
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   193
  /* new one */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   194
  luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   195
  luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   196
                  TString *, MAX_INT, "");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   197
  while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   198
  f->upvalues[f->nups] = name;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   199
  luaC_objbarrier(fs->L, f, name);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   200
  lua_assert(v->k == VLOCAL || v->k == VUPVAL);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   201
  fs->upvalues[f->nups].k = cast_byte(v->k);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   202
  fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   203
  return f->nups++;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   204
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   205
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   206
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   207
static int searchvar (FuncState *fs, TString *n) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   208
  int i;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   209
  for (i=fs->nactvar-1; i >= 0; i--) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   210
    if (n == getlocvar(fs, i).varname)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   211
      return i;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   212
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   213
  return -1;  /* not found */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   214
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   215
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   216
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   217
static void markupval (FuncState *fs, int level) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   218
  BlockCnt *bl = fs->bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   219
  while (bl && bl->nactvar > level) bl = bl->previous;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   220
  if (bl) bl->upval = 1;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   221
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   222
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   223
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   224
static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   225
  if (fs == NULL) {  /* no more levels? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   226
    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   227
    return VGLOBAL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   228
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   229
  else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   230
    int v = searchvar(fs, n);  /* look up at current level */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   231
    if (v >= 0) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   232
      init_exp(var, VLOCAL, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   233
      if (!base)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   234
        markupval(fs, v);  /* local will be used as an upval */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   235
      return VLOCAL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   236
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   237
    else {  /* not found at current level; try upper one */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   238
      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   239
        return VGLOBAL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   240
      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   241
      var->k = VUPVAL;  /* upvalue in this level */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   242
      return VUPVAL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   243
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   244
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   245
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   246
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   247
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   248
static void singlevar (LexState *ls, expdesc *var) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   249
  TString *varname = str_checkname(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   250
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   251
  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   252
    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   253
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   254
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   255
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   256
static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   257
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   258
  int extra = nvars - nexps;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   259
  if (hasmultret(e->k)) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   260
    extra++;  /* includes call itself */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   261
    if (extra < 0) extra = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   262
    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   263
    if (extra > 1) luaK_reserveregs(fs, extra-1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   264
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   265
  else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   266
    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   267
    if (extra > 0) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   268
      int reg = fs->freereg;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   269
      luaK_reserveregs(fs, extra);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   270
      luaK_nil(fs, reg, extra);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   271
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   272
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   273
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   274
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   275
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   276
static void enterlevel (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   277
  if (++ls->L->nCcalls > LUAI_MAXCCALLS)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   278
	luaX_lexerror(ls, "chunk has too many syntax levels", 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   279
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   280
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   281
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   282
#define leavelevel(ls)	((ls)->L->nCcalls--)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   283
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   284
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   285
static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   286
  bl->breaklist = NO_JUMP;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   287
  bl->isbreakable = isbreakable;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   288
  bl->nactvar = fs->nactvar;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   289
  bl->upval = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   290
  bl->previous = fs->bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   291
  fs->bl = bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   292
  lua_assert(fs->freereg == fs->nactvar);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   293
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   294
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   295
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   296
static void leaveblock (FuncState *fs) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   297
  BlockCnt *bl = fs->bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   298
  fs->bl = bl->previous;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   299
  removevars(fs->ls, bl->nactvar);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   300
  if (bl->upval)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   301
    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   302
  /* a block either controls scope or breaks (never both) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   303
  lua_assert(!bl->isbreakable || !bl->upval);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   304
  lua_assert(bl->nactvar == fs->nactvar);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   305
  fs->freereg = fs->nactvar;  /* free registers */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   306
  luaK_patchtohere(fs, bl->breaklist);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   307
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   308
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   309
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   310
static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   311
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   312
  Proto *f = fs->f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   313
  int oldsize = f->sizep;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   314
  int i;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   315
  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   316
                  MAXARG_Bx, "constant table overflow");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   317
  while (oldsize < f->sizep) f->p[oldsize++] = NULL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   318
  f->p[fs->np++] = func->f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   319
  luaC_objbarrier(ls->L, f, func->f);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   320
  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   321
  for (i=0; i<func->f->nups; i++) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   322
    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   323
    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   324
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   325
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   326
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   327
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   328
static void open_func (LexState *ls, FuncState *fs) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   329
  lua_State *L = ls->L;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   330
  Proto *f = luaF_newproto(L);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   331
  fs->f = f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   332
  fs->prev = ls->fs;  /* linked list of funcstates */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   333
  fs->ls = ls;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   334
  fs->L = L;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   335
  ls->fs = fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   336
  fs->pc = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   337
  fs->lasttarget = -1;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   338
  fs->jpc = NO_JUMP;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   339
  fs->freereg = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   340
  fs->nk = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   341
  fs->np = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   342
  fs->nlocvars = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   343
  fs->nactvar = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   344
  fs->bl = NULL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   345
  f->source = ls->source;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   346
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   347
  fs->h = luaH_new(L, 0, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   348
  /* anchor table of constants and prototype (to avoid being collected) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   349
  sethvalue2s(L, L->top, fs->h);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   350
  incr_top(L);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   351
  setptvalue2s(L, L->top, f);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   352
  incr_top(L);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   353
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   354
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   355
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   356
static void close_func (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   357
  lua_State *L = ls->L;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   358
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   359
  Proto *f = fs->f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   360
  removevars(ls, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   361
  luaK_ret(fs, 0, 0);  /* final return */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   362
  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   363
  f->sizecode = fs->pc;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   364
  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   365
  f->sizelineinfo = fs->pc;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   366
  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   367
  f->sizek = fs->nk;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   368
  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   369
  f->sizep = fs->np;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   370
  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   371
  f->sizelocvars = fs->nlocvars;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   372
  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   373
  f->sizeupvalues = f->nups;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   374
  lua_assert(luaG_checkcode(f));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   375
  lua_assert(fs->bl == NULL);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   376
  ls->fs = fs->prev;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   377
  L->top -= 2;  /* remove table and prototype from the stack */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   378
  /* last token read was anchored in defunct function; must reanchor it */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   379
  if (fs) anchor_token(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   380
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   381
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   382
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   383
Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   384
  struct LexState lexstate;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   385
  struct FuncState funcstate;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   386
  lexstate.buff = buff;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   387
  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   388
  open_func(&lexstate, &funcstate);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   389
  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   390
  luaX_next(&lexstate);  /* read first token */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   391
  chunk(&lexstate);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   392
  check(&lexstate, TK_EOS);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   393
  close_func(&lexstate);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   394
  lua_assert(funcstate.prev == NULL);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   395
  lua_assert(funcstate.f->nups == 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   396
  lua_assert(lexstate.fs == NULL);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   397
  return funcstate.f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   398
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   399
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   400
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   401
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   402
/*============================================================*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   403
/* GRAMMAR RULES */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   404
/*============================================================*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   405
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   406
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   407
static void field (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   408
  /* field -> ['.' | ':'] NAME */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   409
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   410
  expdesc key;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   411
  luaK_exp2anyreg(fs, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   412
  luaX_next(ls);  /* skip the dot or colon */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   413
  checkname(ls, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   414
  luaK_indexed(fs, v, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   415
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   416
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   417
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   418
static void yindex (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   419
  /* index -> '[' expr ']' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   420
  luaX_next(ls);  /* skip the '[' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   421
  expr(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   422
  luaK_exp2val(ls->fs, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   423
  checknext(ls, ']');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   424
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   425
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   426
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   427
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   428
** {======================================================================
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   429
** Rules for Constructors
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   430
** =======================================================================
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   431
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   432
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   433
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   434
struct ConsControl {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   435
  expdesc v;  /* last list item read */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   436
  expdesc *t;  /* table descriptor */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   437
  int nh;  /* total number of `record' elements */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   438
  int na;  /* total number of array elements */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   439
  int tostore;  /* number of array elements pending to be stored */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   440
};
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   441
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   442
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   443
static void recfield (LexState *ls, struct ConsControl *cc) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   444
  /* recfield -> (NAME | `['exp1`]') = exp1 */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   445
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   446
  int reg = ls->fs->freereg;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   447
  expdesc key, val;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   448
  int rkkey;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   449
  if (ls->t.token == TK_NAME) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   450
    luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   451
    checkname(ls, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   452
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   453
  else  /* ls->t.token == '[' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   454
    yindex(ls, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   455
  cc->nh++;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   456
  checknext(ls, '=');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   457
  rkkey = luaK_exp2RK(fs, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   458
  expr(ls, &val);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   459
  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   460
  fs->freereg = reg;  /* free registers */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   461
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   462
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   463
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   464
static void closelistfield (FuncState *fs, struct ConsControl *cc) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   465
  if (cc->v.k == VVOID) return;  /* there is no list item */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   466
  luaK_exp2nextreg(fs, &cc->v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   467
  cc->v.k = VVOID;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   468
  if (cc->tostore == LFIELDS_PER_FLUSH) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   469
    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   470
    cc->tostore = 0;  /* no more items pending */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   471
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   472
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   473
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   474
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   475
static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   476
  if (cc->tostore == 0) return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   477
  if (hasmultret(cc->v.k)) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   478
    luaK_setmultret(fs, &cc->v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   479
    luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   480
    cc->na--;  /* do not count last expression (unknown number of elements) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   481
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   482
  else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   483
    if (cc->v.k != VVOID)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   484
      luaK_exp2nextreg(fs, &cc->v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   485
    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   486
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   487
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   488
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   489
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   490
static void listfield (LexState *ls, struct ConsControl *cc) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   491
  expr(ls, &cc->v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   492
  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   493
  cc->na++;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   494
  cc->tostore++;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   495
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   496
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   497
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   498
static void constructor (LexState *ls, expdesc *t) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   499
  /* constructor -> ?? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   500
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   501
  int line = ls->linenumber;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   502
  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   503
  struct ConsControl cc;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   504
  cc.na = cc.nh = cc.tostore = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   505
  cc.t = t;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   506
  init_exp(t, VRELOCABLE, pc);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   507
  init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   508
  luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top (for gc) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   509
  checknext(ls, '{');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   510
  do {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   511
    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   512
    if (ls->t.token == '}') break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   513
    closelistfield(fs, &cc);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   514
    switch(ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   515
      case TK_NAME: {  /* may be listfields or recfields */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   516
        luaX_lookahead(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   517
        if (ls->lookahead.token != '=')  /* expression? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   518
          listfield(ls, &cc);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   519
        else
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   520
          recfield(ls, &cc);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   521
        break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   522
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   523
      case '[': {  /* constructor_item -> recfield */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   524
        recfield(ls, &cc);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   525
        break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   526
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   527
      default: {  /* constructor_part -> listfield */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   528
        listfield(ls, &cc);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   529
        break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   530
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   531
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   532
  } while (testnext(ls, ',') || testnext(ls, ';'));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   533
  check_match(ls, '}', '{', line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   534
  lastlistfield(fs, &cc);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   535
  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   536
  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   537
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   538
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   539
/* }====================================================================== */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   540
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   541
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   542
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   543
static void parlist (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   544
  /* parlist -> [ param { `,' param } ] */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   545
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   546
  Proto *f = fs->f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   547
  int nparams = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   548
  f->is_vararg = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   549
  if (ls->t.token != ')') {  /* is `parlist' not empty? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   550
    do {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   551
      switch (ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   552
        case TK_NAME: {  /* param -> NAME */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   553
          new_localvar(ls, str_checkname(ls), nparams++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   554
          break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   555
        }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   556
        case TK_DOTS: {  /* param -> `...' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   557
          luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   558
#if defined(LUA_COMPAT_VARARG)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   559
          /* use `arg' as default name */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   560
          new_localvarliteral(ls, "arg", nparams++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   561
          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   562
#endif
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   563
          f->is_vararg |= VARARG_ISVARARG;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   564
          break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   565
        }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   566
        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   567
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   568
    } while (!f->is_vararg && testnext(ls, ','));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   569
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   570
  adjustlocalvars(ls, nparams);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   571
  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   572
  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   573
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   574
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   575
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   576
static void body (LexState *ls, expdesc *e, int needself, int line) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   577
  /* body ->  `(' parlist `)' chunk END */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   578
  FuncState new_fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   579
  open_func(ls, &new_fs);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   580
  new_fs.f->linedefined = line;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   581
  checknext(ls, '(');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   582
  if (needself) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   583
    new_localvarliteral(ls, "self", 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   584
    adjustlocalvars(ls, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   585
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   586
  parlist(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   587
  checknext(ls, ')');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   588
  chunk(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   589
  new_fs.f->lastlinedefined = ls->linenumber;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   590
  check_match(ls, TK_END, TK_FUNCTION, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   591
  close_func(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   592
  pushclosure(ls, &new_fs, e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   593
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   594
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   595
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   596
static int explist1 (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   597
  /* explist1 -> expr { `,' expr } */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   598
  int n = 1;  /* at least one expression */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   599
  expr(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   600
  while (testnext(ls, ',')) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   601
    luaK_exp2nextreg(ls->fs, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   602
    expr(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   603
    n++;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   604
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   605
  return n;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   606
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   607
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   608
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   609
static void funcargs (LexState *ls, expdesc *f) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   610
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   611
  expdesc args;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   612
  int base, nparams;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   613
  int line = ls->linenumber;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   614
  switch (ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   615
    case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   616
      if (line != ls->lastline)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   617
        luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   618
      luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   619
      if (ls->t.token == ')')  /* arg list is empty? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   620
        args.k = VVOID;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   621
      else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   622
        explist1(ls, &args);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   623
        luaK_setmultret(fs, &args);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   624
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   625
      check_match(ls, ')', '(', line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   626
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   627
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   628
    case '{': {  /* funcargs -> constructor */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   629
      constructor(ls, &args);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   630
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   631
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   632
    case TK_STRING: {  /* funcargs -> STRING */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   633
      codestring(ls, &args, ls->t.seminfo.ts);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   634
      luaX_next(ls);  /* must use `seminfo' before `next' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   635
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   636
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   637
    default: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   638
      luaX_syntaxerror(ls, "function arguments expected");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   639
      return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   640
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   641
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   642
  lua_assert(f->k == VNONRELOC);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   643
  base = f->u.s.info;  /* base register for call */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   644
  if (hasmultret(args.k))
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   645
    nparams = LUA_MULTRET;  /* open call */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   646
  else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   647
    if (args.k != VVOID)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   648
      luaK_exp2nextreg(fs, &args);  /* close last argument */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   649
    nparams = fs->freereg - (base+1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   650
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   651
  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   652
  luaK_fixline(fs, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   653
  fs->freereg = base+1;  /* call remove function and arguments and leaves
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   654
                            (unless changed) one result */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   655
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   656
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   657
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   658
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   659
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   660
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   661
** {======================================================================
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   662
** Expression parsing
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   663
** =======================================================================
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   664
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   665
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   666
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   667
static void prefixexp (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   668
  /* prefixexp -> NAME | '(' expr ')' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   669
  switch (ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   670
    case '(': {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   671
      int line = ls->linenumber;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   672
      luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   673
      expr(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   674
      check_match(ls, ')', '(', line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   675
      luaK_dischargevars(ls->fs, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   676
      return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   677
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   678
    case TK_NAME: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   679
      singlevar(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   680
      return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   681
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   682
    default: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   683
      luaX_syntaxerror(ls, "unexpected symbol");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   684
      return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   685
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   686
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   687
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   688
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   689
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   690
static void primaryexp (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   691
  /* primaryexp ->
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   692
        prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   693
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   694
  prefixexp(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   695
  for (;;) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   696
    switch (ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   697
      case '.': {  /* field */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   698
        field(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   699
        break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   700
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   701
      case '[': {  /* `[' exp1 `]' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   702
        expdesc key;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   703
        luaK_exp2anyreg(fs, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   704
        yindex(ls, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   705
        luaK_indexed(fs, v, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   706
        break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   707
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   708
      case ':': {  /* `:' NAME funcargs */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   709
        expdesc key;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   710
        luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   711
        checkname(ls, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   712
        luaK_self(fs, v, &key);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   713
        funcargs(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   714
        break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   715
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   716
      case '(': case TK_STRING: case '{': {  /* funcargs */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   717
        luaK_exp2nextreg(fs, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   718
        funcargs(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   719
        break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   720
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   721
      default: return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   722
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   723
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   724
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   725
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   726
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   727
static void simpleexp (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   728
  /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   729
                  constructor | FUNCTION body | primaryexp */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   730
  switch (ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   731
    case TK_NUMBER: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   732
      init_exp(v, VKNUM, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   733
      v->u.nval = ls->t.seminfo.r;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   734
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   735
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   736
    case TK_STRING: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   737
      codestring(ls, v, ls->t.seminfo.ts);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   738
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   739
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   740
    case TK_NIL: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   741
      init_exp(v, VNIL, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   742
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   743
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   744
    case TK_TRUE: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   745
      init_exp(v, VTRUE, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   746
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   747
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   748
    case TK_FALSE: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   749
      init_exp(v, VFALSE, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   750
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   751
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   752
    case TK_DOTS: {  /* vararg */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   753
      FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   754
      check_condition(ls, fs->f->is_vararg,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   755
                      "cannot use " LUA_QL("...") " outside a vararg function");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   756
      fs->f->is_vararg &= ~VARARG_NEEDSARG;  /* don't need 'arg' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   757
      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   758
      break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   759
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   760
    case '{': {  /* constructor */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   761
      constructor(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   762
      return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   763
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   764
    case TK_FUNCTION: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   765
      luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   766
      body(ls, v, 0, ls->linenumber);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   767
      return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   768
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   769
    default: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   770
      primaryexp(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   771
      return;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   772
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   773
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   774
  luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   775
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   776
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   777
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   778
static UnOpr getunopr (int op) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   779
  switch (op) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   780
    case TK_NOT: return OPR_NOT;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   781
    case '-': return OPR_MINUS;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   782
    case '#': return OPR_LEN;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   783
    default: return OPR_NOUNOPR;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   784
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   785
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   786
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   787
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   788
static BinOpr getbinopr (int op) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   789
  switch (op) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   790
    case '+': return OPR_ADD;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   791
    case '-': return OPR_SUB;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   792
    case '*': return OPR_MUL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   793
    case '/': return OPR_DIV;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   794
    case '%': return OPR_MOD;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   795
    case '^': return OPR_POW;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   796
    case TK_CONCAT: return OPR_CONCAT;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   797
    case TK_NE: return OPR_NE;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   798
    case TK_EQ: return OPR_EQ;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   799
    case '<': return OPR_LT;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   800
    case TK_LE: return OPR_LE;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   801
    case '>': return OPR_GT;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   802
    case TK_GE: return OPR_GE;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   803
    case TK_AND: return OPR_AND;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   804
    case TK_OR: return OPR_OR;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   805
    default: return OPR_NOBINOPR;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   806
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   807
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   808
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   809
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   810
static const struct {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   811
  lu_byte left;  /* left priority for each binary operator */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   812
  lu_byte right; /* right priority */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   813
} priority[] = {  /* ORDER OPR */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   814
   {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   815
   {10, 9}, {5, 4},                 /* power and concat (right associative) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   816
   {3, 3}, {3, 3},                  /* equality and inequality */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   817
   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   818
   {2, 2}, {1, 1}                   /* logical (and/or) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   819
};
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   820
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   821
#define UNARY_PRIORITY	8  /* priority for unary operators */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   822
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   823
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   824
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   825
** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   826
** where `binop' is any binary operator with a priority higher than `limit'
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   827
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   828
static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   829
  BinOpr op;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   830
  UnOpr uop;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   831
  enterlevel(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   832
  uop = getunopr(ls->t.token);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   833
  if (uop != OPR_NOUNOPR) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   834
    luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   835
    subexpr(ls, v, UNARY_PRIORITY);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   836
    luaK_prefix(ls->fs, uop, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   837
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   838
  else simpleexp(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   839
  /* expand while operators have priorities higher than `limit' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   840
  op = getbinopr(ls->t.token);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   841
  while (op != OPR_NOBINOPR && priority[op].left > limit) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   842
    expdesc v2;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   843
    BinOpr nextop;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   844
    luaX_next(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   845
    luaK_infix(ls->fs, op, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   846
    /* read sub-expression with higher priority */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   847
    nextop = subexpr(ls, &v2, priority[op].right);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   848
    luaK_posfix(ls->fs, op, v, &v2);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   849
    op = nextop;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   850
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   851
  leavelevel(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   852
  return op;  /* return first untreated operator */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   853
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   854
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   855
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   856
static void expr (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   857
  subexpr(ls, v, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   858
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   859
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   860
/* }==================================================================== */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   861
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   862
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   863
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   864
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   865
** {======================================================================
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   866
** Rules for Statements
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   867
** =======================================================================
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   868
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   869
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   870
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   871
static int block_follow (int token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   872
  switch (token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   873
    case TK_ELSE: case TK_ELSEIF: case TK_END:
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   874
    case TK_UNTIL: case TK_EOS:
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   875
      return 1;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   876
    default: return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   877
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   878
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   879
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   880
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   881
static void block (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   882
  /* block -> chunk */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   883
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   884
  BlockCnt bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   885
  enterblock(fs, &bl, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   886
  chunk(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   887
  lua_assert(bl.breaklist == NO_JUMP);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   888
  leaveblock(fs);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   889
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   890
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   891
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   892
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   893
** structure to chain all variables in the left-hand side of an
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   894
** assignment
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   895
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   896
struct LHS_assign {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   897
  struct LHS_assign *prev;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   898
  expdesc v;  /* variable (global, local, upvalue, or indexed) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   899
};
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   900
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   901
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   902
/*
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   903
** check whether, in an assignment to a local variable, the local variable
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   904
** is needed in a previous assignment (to a table). If so, save original
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   905
** local value in a safe place and use this safe copy in the previous
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   906
** assignment.
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   907
*/
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   908
static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   909
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   910
  int extra = fs->freereg;  /* eventual position to save local variable */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   911
  int conflict = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   912
  for (; lh; lh = lh->prev) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   913
    if (lh->v.k == VINDEXED) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   914
      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   915
        conflict = 1;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   916
        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   917
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   918
      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   919
        conflict = 1;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   920
        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   921
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   922
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   923
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   924
  if (conflict) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   925
    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   926
    luaK_reserveregs(fs, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   927
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   928
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   929
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   930
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   931
static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   932
  expdesc e;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   933
  check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   934
                      "syntax error");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   935
  if (testnext(ls, ',')) {  /* assignment -> `,' primaryexp assignment */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   936
    struct LHS_assign nv;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   937
    nv.prev = lh;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   938
    primaryexp(ls, &nv.v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   939
    if (nv.v.k == VLOCAL)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   940
      check_conflict(ls, lh, &nv.v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   941
    luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   942
                    "variables in assignment");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   943
    assignment(ls, &nv, nvars+1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   944
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   945
  else {  /* assignment -> `=' explist1 */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   946
    int nexps;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   947
    checknext(ls, '=');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   948
    nexps = explist1(ls, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   949
    if (nexps != nvars) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   950
      adjust_assign(ls, nvars, nexps, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   951
      if (nexps > nvars)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   952
        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   953
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   954
    else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   955
      luaK_setoneret(ls->fs, &e);  /* close last expression */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   956
      luaK_storevar(ls->fs, &lh->v, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   957
      return;  /* avoid default */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   958
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   959
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   960
  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   961
  luaK_storevar(ls->fs, &lh->v, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   962
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   963
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   964
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   965
static int cond (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   966
  /* cond -> exp */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   967
  expdesc v;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   968
  expr(ls, &v);  /* read condition */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   969
  if (v.k == VNIL) v.k = VFALSE;  /* `falses' are all equal here */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   970
  luaK_goiftrue(ls->fs, &v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   971
  return v.f;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   972
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   973
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   974
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   975
static void breakstat (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   976
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   977
  BlockCnt *bl = fs->bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   978
  int upval = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   979
  while (bl && !bl->isbreakable) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   980
    upval |= bl->upval;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   981
    bl = bl->previous;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   982
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   983
  if (!bl)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   984
    luaX_syntaxerror(ls, "no loop to break");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   985
  if (upval)
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   986
    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   987
  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   988
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   989
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   990
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   991
static void whilestat (LexState *ls, int line) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   992
  /* whilestat -> WHILE cond DO block END */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   993
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   994
  int whileinit;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   995
  int condexit;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   996
  BlockCnt bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   997
  luaX_next(ls);  /* skip WHILE */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   998
  whileinit = luaK_getlabel(fs);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
   999
  condexit = cond(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1000
  enterblock(fs, &bl, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1001
  checknext(ls, TK_DO);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1002
  block(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1003
  luaK_patchlist(fs, luaK_jump(fs), whileinit);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1004
  check_match(ls, TK_END, TK_WHILE, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1005
  leaveblock(fs);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1006
  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1007
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1008
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1009
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1010
static void repeatstat (LexState *ls, int line) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1011
  /* repeatstat -> REPEAT block UNTIL cond */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1012
  int condexit;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1013
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1014
  int repeat_init = luaK_getlabel(fs);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1015
  BlockCnt bl1, bl2;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1016
  enterblock(fs, &bl1, 1);  /* loop block */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1017
  enterblock(fs, &bl2, 0);  /* scope block */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1018
  luaX_next(ls);  /* skip REPEAT */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1019
  chunk(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1020
  check_match(ls, TK_UNTIL, TK_REPEAT, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1021
  condexit = cond(ls);  /* read condition (inside scope block) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1022
  if (!bl2.upval) {  /* no upvalues? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1023
    leaveblock(fs);  /* finish scope */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1024
    luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1025
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1026
  else {  /* complete semantics when there are upvalues */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1027
    breakstat(ls);  /* if condition then break */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1028
    luaK_patchtohere(ls->fs, condexit);  /* else... */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1029
    leaveblock(fs);  /* finish scope... */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1030
    luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1031
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1032
  leaveblock(fs);  /* finish loop */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1033
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1034
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1035
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1036
static int exp1 (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1037
  expdesc e;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1038
  int k;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1039
  expr(ls, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1040
  k = e.k;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1041
  luaK_exp2nextreg(ls->fs, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1042
  return k;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1043
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1044
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1045
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1046
static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1047
  /* forbody -> DO block */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1048
  BlockCnt bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1049
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1050
  int prep, endfor;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1051
  adjustlocalvars(ls, 3);  /* control variables */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1052
  checknext(ls, TK_DO);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1053
  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1054
  enterblock(fs, &bl, 0);  /* scope for declared variables */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1055
  adjustlocalvars(ls, nvars);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1056
  luaK_reserveregs(fs, nvars);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1057
  block(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1058
  leaveblock(fs);  /* end of scope for declared variables */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1059
  luaK_patchtohere(fs, prep);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1060
  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1061
                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1062
  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1063
  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1064
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1065
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1066
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1067
static void fornum (LexState *ls, TString *varname, int line) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1068
  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1069
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1070
  int base = fs->freereg;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1071
  new_localvarliteral(ls, "(for index)", 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1072
  new_localvarliteral(ls, "(for limit)", 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1073
  new_localvarliteral(ls, "(for step)", 2);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1074
  new_localvar(ls, varname, 3);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1075
  checknext(ls, '=');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1076
  exp1(ls);  /* initial value */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1077
  checknext(ls, ',');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1078
  exp1(ls);  /* limit */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1079
  if (testnext(ls, ','))
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1080
    exp1(ls);  /* optional step */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1081
  else {  /* default step = 1 */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1082
    luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1083
    luaK_reserveregs(fs, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1084
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1085
  forbody(ls, base, line, 1, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1086
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1087
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1088
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1089
static void forlist (LexState *ls, TString *indexname) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1090
  /* forlist -> NAME {,NAME} IN explist1 forbody */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1091
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1092
  expdesc e;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1093
  int nvars = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1094
  int line;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1095
  int base = fs->freereg;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1096
  /* create control variables */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1097
  new_localvarliteral(ls, "(for generator)", nvars++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1098
  new_localvarliteral(ls, "(for state)", nvars++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1099
  new_localvarliteral(ls, "(for control)", nvars++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1100
  /* create declared variables */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1101
  new_localvar(ls, indexname, nvars++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1102
  while (testnext(ls, ','))
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1103
    new_localvar(ls, str_checkname(ls), nvars++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1104
  checknext(ls, TK_IN);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1105
  line = ls->linenumber;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1106
  adjust_assign(ls, 3, explist1(ls, &e), &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1107
  luaK_checkstack(fs, 3);  /* extra space to call generator */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1108
  forbody(ls, base, line, nvars - 3, 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1109
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1110
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1111
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1112
static void forstat (LexState *ls, int line) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1113
  /* forstat -> FOR (fornum | forlist) END */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1114
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1115
  TString *varname;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1116
  BlockCnt bl;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1117
  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1118
  luaX_next(ls);  /* skip `for' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1119
  varname = str_checkname(ls);  /* first variable name */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1120
  switch (ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1121
    case '=': fornum(ls, varname, line); break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1122
    case ',': case TK_IN: forlist(ls, varname); break;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1123
    default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1124
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1125
  check_match(ls, TK_END, TK_FOR, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1126
  leaveblock(fs);  /* loop scope (`break' jumps to this point) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1127
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1128
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1129
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1130
static int test_then_block (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1131
  /* test_then_block -> [IF | ELSEIF] cond THEN block */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1132
  int condexit;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1133
  luaX_next(ls);  /* skip IF or ELSEIF */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1134
  condexit = cond(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1135
  checknext(ls, TK_THEN);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1136
  block(ls);  /* `then' part */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1137
  return condexit;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1138
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1139
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1140
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1141
static void ifstat (LexState *ls, int line) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1142
  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1143
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1144
  int flist;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1145
  int escapelist = NO_JUMP;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1146
  flist = test_then_block(ls);  /* IF cond THEN block */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1147
  while (ls->t.token == TK_ELSEIF) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1148
    luaK_concat(fs, &escapelist, luaK_jump(fs));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1149
    luaK_patchtohere(fs, flist);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1150
    flist = test_then_block(ls);  /* ELSEIF cond THEN block */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1151
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1152
  if (ls->t.token == TK_ELSE) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1153
    luaK_concat(fs, &escapelist, luaK_jump(fs));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1154
    luaK_patchtohere(fs, flist);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1155
    luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1156
    block(ls);  /* `else' part */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1157
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1158
  else
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1159
    luaK_concat(fs, &escapelist, flist);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1160
  luaK_patchtohere(fs, escapelist);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1161
  check_match(ls, TK_END, TK_IF, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1162
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1163
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1164
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1165
static void localfunc (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1166
  expdesc v, b;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1167
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1168
  new_localvar(ls, str_checkname(ls), 0);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1169
  init_exp(&v, VLOCAL, fs->freereg);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1170
  luaK_reserveregs(fs, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1171
  adjustlocalvars(ls, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1172
  body(ls, &b, 0, ls->linenumber);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1173
  luaK_storevar(fs, &v, &b);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1174
  /* debug information will only see the variable after this point! */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1175
  getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1176
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1177
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1178
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1179
static void localstat (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1180
  /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1181
  int nvars = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1182
  int nexps;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1183
  expdesc e;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1184
  do {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1185
    new_localvar(ls, str_checkname(ls), nvars++);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1186
  } while (testnext(ls, ','));
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1187
  if (testnext(ls, '='))
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1188
    nexps = explist1(ls, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1189
  else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1190
    e.k = VVOID;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1191
    nexps = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1192
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1193
  adjust_assign(ls, nvars, nexps, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1194
  adjustlocalvars(ls, nvars);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1195
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1196
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1197
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1198
static int funcname (LexState *ls, expdesc *v) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1199
  /* funcname -> NAME {field} [`:' NAME] */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1200
  int needself = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1201
  singlevar(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1202
  while (ls->t.token == '.')
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1203
    field(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1204
  if (ls->t.token == ':') {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1205
    needself = 1;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1206
    field(ls, v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1207
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1208
  return needself;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1209
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1210
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1211
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1212
static void funcstat (LexState *ls, int line) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1213
  /* funcstat -> FUNCTION funcname body */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1214
  int needself;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1215
  expdesc v, b;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1216
  luaX_next(ls);  /* skip FUNCTION */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1217
  needself = funcname(ls, &v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1218
  body(ls, &b, needself, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1219
  luaK_storevar(ls->fs, &v, &b);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1220
  luaK_fixline(ls->fs, line);  /* definition `happens' in the first line */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1221
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1222
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1223
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1224
static void exprstat (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1225
  /* stat -> func | assignment */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1226
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1227
  struct LHS_assign v;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1228
  primaryexp(ls, &v.v);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1229
  if (v.v.k == VCALL)  /* stat -> func */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1230
    SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1231
  else {  /* stat -> assignment */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1232
    v.prev = NULL;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1233
    assignment(ls, &v, 1);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1234
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1235
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1236
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1237
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1238
static void retstat (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1239
  /* stat -> RETURN explist */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1240
  FuncState *fs = ls->fs;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1241
  expdesc e;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1242
  int first, nret;  /* registers with returned values */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1243
  luaX_next(ls);  /* skip RETURN */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1244
  if (block_follow(ls->t.token) || ls->t.token == ';')
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1245
    first = nret = 0;  /* return no values */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1246
  else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1247
    nret = explist1(ls, &e);  /* optional return values */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1248
    if (hasmultret(e.k)) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1249
      luaK_setmultret(fs, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1250
      if (e.k == VCALL && nret == 1) {  /* tail call? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1251
        SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1252
        lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1253
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1254
      first = fs->nactvar;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1255
      nret = LUA_MULTRET;  /* return all values */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1256
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1257
    else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1258
      if (nret == 1)  /* only one single value? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1259
        first = luaK_exp2anyreg(fs, &e);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1260
      else {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1261
        luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1262
        first = fs->nactvar;  /* return all `active' values */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1263
        lua_assert(nret == fs->freereg - first);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1264
      }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1265
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1266
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1267
  luaK_ret(fs, first, nret);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1268
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1269
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1270
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1271
static int statement (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1272
  int line = ls->linenumber;  /* may be needed for error messages */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1273
  switch (ls->t.token) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1274
    case TK_IF: {  /* stat -> ifstat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1275
      ifstat(ls, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1276
      return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1277
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1278
    case TK_WHILE: {  /* stat -> whilestat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1279
      whilestat(ls, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1280
      return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1281
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1282
    case TK_DO: {  /* stat -> DO block END */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1283
      luaX_next(ls);  /* skip DO */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1284
      block(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1285
      check_match(ls, TK_END, TK_DO, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1286
      return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1287
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1288
    case TK_FOR: {  /* stat -> forstat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1289
      forstat(ls, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1290
      return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1291
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1292
    case TK_REPEAT: {  /* stat -> repeatstat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1293
      repeatstat(ls, line);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1294
      return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1295
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1296
    case TK_FUNCTION: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1297
      funcstat(ls, line);  /* stat -> funcstat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1298
      return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1299
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1300
    case TK_LOCAL: {  /* stat -> localstat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1301
      luaX_next(ls);  /* skip LOCAL */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1302
      if (testnext(ls, TK_FUNCTION))  /* local function? */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1303
        localfunc(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1304
      else
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1305
        localstat(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1306
      return 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1307
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1308
    case TK_RETURN: {  /* stat -> retstat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1309
      retstat(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1310
      return 1;  /* must be last statement */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1311
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1312
    case TK_BREAK: {  /* stat -> breakstat */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1313
      luaX_next(ls);  /* skip BREAK */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1314
      breakstat(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1315
      return 1;  /* must be last statement */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1316
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1317
    default: {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1318
      exprstat(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1319
      return 0;  /* to avoid warnings */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1320
    }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1321
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1322
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1323
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1324
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1325
static void chunk (LexState *ls) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1326
  /* chunk -> { stat [`;'] } */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1327
  int islast = 0;
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1328
  enterlevel(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1329
  while (!islast && !block_follow(ls->t.token)) {
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1330
    islast = statement(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1331
    testnext(ls, ';');
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1332
    lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1333
               ls->fs->freereg >= ls->fs->nactvar);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1334
    ls->fs->freereg = ls->fs->nactvar;  /* free registers */
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1335
  }
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1336
  leavelevel(ls);
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1337
}
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1338
0a24853de796 add liblua to sources for macosx
koda
parents:
diff changeset
  1339
/* }====================================================================== */