⛄ Sync 2026-04-23 20:32:35

luci-base/src/Makefile

@@ -0,0 +1,34 @@
+%.o: %.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(FPIC) -DNDEBUG -c -o $@ $<
+
+contrib/lemon: contrib/lemon.c contrib/lempar.c
+	cc -std=gnu17 -o contrib/lemon $<
+
+lib/plural_formula.c: lib/plural_formula.y contrib/lemon
+	./contrib/lemon -q $<
+
+lib/lmo.c: lib/plural_formula.c
+
+core.so: lib/luci.o lib/lmo.o lib/plural_formula.o
+	$(CC) $(LDFLAGS) -shared -lcrypt -o $@ $^
+
+version.uc:
+	echo "export const revision = '$(LUCI_VERSION)', branch = '$(LUCI_GITBRANCH)';" > $@
+
+clean:
+	rm -f contrib/lemon lib/*.o lib/plural_formula.c lib/plural_formula.h *.o core.so jsmin po2lmo version.uc
+
+jsmin: jsmin.o
+	$(CC) $(LDFLAGS) -o $@ $^
+
+po2lmo: po2lmo.o lib/lmo.o lib/plural_formula.o
+	$(CC) $(LDFLAGS) -o $@ $^
+
+compile: core.so version.uc
+
+install: compile
+	mkdir -p $(DESTDIR)/usr/lib/ucode/luci
+	cp core.so $(DESTDIR)/usr/lib/ucode/luci/core.so
+
+	mkdir -p $(DESTDIR)/usr/share/ucode/luci
+	cp version.uc $(DESTDIR)/usr/share/ucode/luci/version.uc

luci-base/src/contrib/lempar.c

@@ -0,0 +1,851 @@
+/* Driver template for the LEMON parser generator.
+** The author disclaims copyright to this source code.
+*/
+/* First off, code is included that follows the "include" declaration
+** in the input grammar file. */
+#include <stdio.h>
+%%
+/* Next is all token values, in a form suitable for use by makeheaders.
+** This section will be null unless lemon is run with the -m switch.
+*/
+/* 
+** These constants (all generated automatically by the parser generator)
+** specify the various kinds of tokens (terminals) that the parser
+** understands. 
+**
+** Each symbol here is a terminal symbol in the grammar.
+*/
+%%
+/* Make sure the INTERFACE macro is defined.
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/* The next thing included is series of defines which control
+** various aspects of the generated parser.
+**    YYCODETYPE         is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 terminals
+**                       and nonterminals.  "int" is used otherwise.
+**    YYNOCODE           is a number of type YYCODETYPE which corresponds
+**                       to no legal terminal or nonterminal number.  This
+**                       number is used to fill in empty slots of the hash 
+**                       table.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       have fall-back values which should be used if the
+**                       original value of the token will not parse.
+**    YYACTIONTYPE       is the data type used for storing terminal
+**                       and nonterminal numbers.  "unsigned char" is
+**                       used if there are fewer than 250 rules and
+**                       states combined.  "int" is used otherwise.
+**    ParseTOKENTYPE     is the data type used for minor tokens given 
+**                       directly to the parser from the tokenizer.
+**    YYMINORTYPE        is the data type used for all minor tokens.
+**                       This is typically a union of many types, one of
+**                       which is ParseTOKENTYPE.  The entry in the union
+**                       for base tokens is called "yy0".
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+**                       zero the stack is dynamically sized using realloc()
+**    ParseARG_SDECL     A static variable declaration for the %extra_argument
+**    ParseARG_PDECL     A parameter declaration for the %extra_argument
+**    ParseARG_STORE     Code to store %extra_argument into yypParser
+**    ParseARG_FETCH     Code to extract %extra_argument from yypParser
+**    YYNSTATE           the combined number of states.
+**    YYNRULE            the number of rules in the grammar
+**    YYERRORSYMBOL      is the code number of the error symbol.  If not
+**                       defined, then do no error processing.
+*/
+%%
+#define YY_NO_ACTION      (YYNSTATE+YYNRULE+2)
+#define YY_ACCEPT_ACTION  (YYNSTATE+YYNRULE+1)
+#define YY_ERROR_ACTION   (YYNSTATE+YYNRULE)
+
+/* The yyzerominor constant is used to initialize instances of
+** YYMINORTYPE objects to zero. */
+static const YYMINORTYPE yyzerominor = { 0 };
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage.  For production
+** code the yytestcase() macro should be turned off.  But it is useful
+** for testing.
+*/
+#ifndef yytestcase
+# define yytestcase(X)
+#endif
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token.  These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.  
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N < YYNSTATE                  Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   YYNSTATE <= N < YYNSTATE+YYNRULE   Reduce by rule N-YYNSTATE.
+**
+**   N == YYNSTATE+YYNRULE              A syntax error has occurred.
+**
+**   N == YYNSTATE+YYNRULE+1            The parser accepts its input.
+**
+**   N == YYNSTATE+YYNRULE+2            No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as
+**
+**      yy_action[ yy_shift_ofst[S] + X ]
+**
+** If the index value yy_shift_ofst[S]+X is out of range or if the value
+** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
+** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
+** and that yy_default[S] should be used instead.  
+**
+** The formula above is for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  yy_shift_ofst[]    For each state, the offset into yy_action for
+**                     shifting terminals.
+**  yy_reduce_ofst[]   For each state, the offset into yy_action for
+**                     shifting non-terminals after a reduce.
+**  yy_default[]       Default action for each state.
+*/
+%%
+
+/* The next table maps tokens into fallback tokens.  If a construct
+** like the following:
+** 
+**      %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+%%
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+*/
+struct yyStackEntry {
+  YYACTIONTYPE stateno;  /* The state-number */
+  YYCODETYPE major;      /* The major token value.  This is the code
+                         ** number for the token at this stack level */
+  YYMINORTYPE minor;     /* The user-supplied minor token value.  This
+                         ** is the value of the token  */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+  int yyidx;                    /* Index of top element in stack */
+#ifdef YYTRACKMAXSTACKDEPTH
+  int yyidxMax;                 /* Maximum value of yyidx */
+#endif
+  int yyerrcnt;                 /* Shifts left before out of the error */
+  ParseARG_SDECL                /* A place to hold %extra_argument */
+#if YYSTACKDEPTH<=0
+  int yystksz;                  /* Current side of the stack */
+  yyStackEntry *yystack;        /* The parser's stack */
+#else
+  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
+#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* 
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL 
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output.  If NULL, then tracing is
+**      turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void ParseTrace(FILE *TraceFILE, char *zTracePrompt);
+void ParseTrace(FILE *TraceFILE, char *zTracePrompt){
+  yyTraceFILE = TraceFILE;
+  yyTracePrompt = zTracePrompt;
+  if( yyTraceFILE==0 ) yyTracePrompt = 0;
+  else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required.  The following table supplies these names */
+static const char *const yyTokenName[] = { 
+%%
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+%%
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack.
+*/
+static void yyGrowStack(yyParser *p){
+  int newSize;
+  yyStackEntry *pNew;
+
+  newSize = p->yystksz*2 + 100;
+  pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+  if( pNew ){
+    p->yystack = pNew;
+    p->yystksz = newSize;
+#ifndef NDEBUG
+    if( yyTraceFILE ){
+      fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
+              yyTracePrompt, p->yystksz);
+    }
+#endif
+  }
+}
+#endif
+
+/* 
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser.  This pointer is used in subsequent calls
+** to Parse and ParseFree.
+*/
+void *ParseAlloc(void *(*mallocProc)(size_t)){
+  yyParser *pParser;
+  pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
+  if( pParser ){
+    pParser->yyidx = -1;
+#ifdef YYTRACKMAXSTACKDEPTH
+    pParser->yyidxMax = 0;
+#endif
+#if YYSTACKDEPTH<=0
+    pParser->yystack = NULL;
+    pParser->yystksz = 0;
+    yyGrowStack(pParser);
+#endif
+  }
+  return pParser;
+}
+
+/* The following function deletes the value associated with a
+** symbol.  The symbol can be either a terminal or nonterminal.
+** "yymajor" is the symbol code, and "yypminor" is a pointer to
+** the value.
+*/
+static void yy_destructor(
+  yyParser *yypParser,    /* The parser */
+  YYCODETYPE yymajor,     /* Type code for object to destroy */
+  YYMINORTYPE *yypminor   /* The object to be destroyed */
+){
+  ParseARG_FETCH;
+  switch( yymajor ){
+    /* Here is inserted the actions which take place when a
+    ** terminal or non-terminal is destroyed.  This can happen
+    ** when the symbol is popped from the stack during a
+    ** reduce or during error processing or when a parser is 
+    ** being destroyed before it is finished parsing.
+    **
+    ** Note: during a reduce, the only symbols destroyed are those
+    ** which appear on the RHS of the rule, but which are not used
+    ** inside the C code.
+    */
+%%
+    default:  break;   /* If no destructor action specified: do nothing */
+  }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+**
+** Return the major token number for the symbol popped.
+*/
+static int yy_pop_parser_stack(yyParser *pParser){
+  YYCODETYPE yymajor;
+  yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
+
+  if( pParser->yyidx<0 ) return 0;
+#ifndef NDEBUG
+  if( yyTraceFILE && pParser->yyidx>=0 ){
+    fprintf(yyTraceFILE,"%sPopping %s\n",
+      yyTracePrompt,
+      yyTokenName[yytos->major]);
+  }
+#endif
+  yymajor = yytos->major;
+  yy_destructor(pParser, yymajor, &yytos->minor);
+  pParser->yyidx--;
+  return yymajor;
+}
+
+/* 
+** Deallocate and destroy a parser.  Destructors are all called for
+** all stack elements before shutting the parser down.
+**
+** Inputs:
+** <ul>
+** <li>  A pointer to the parser.  This should be a pointer
+**       obtained from ParseAlloc.
+** <li>  A pointer to a function used to reclaim memory obtained
+**       from malloc.
+** </ul>
+*/
+void ParseFree(
+  void *p,                    /* The parser to be deleted */
+  void (*freeProc)(void*)     /* Function used to reclaim memory */
+){
+  yyParser *pParser = (yyParser*)p;
+  if( pParser==0 ) return;
+  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
+#if YYSTACKDEPTH<=0
+  free(pParser->yystack);
+#endif
+  (*freeProc)((void*)pParser);
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+#ifdef YYTRACKMAXSTACKDEPTH
+int ParseStackPeak(void *p){
+  yyParser *pParser = (yyParser*)p;
+  return pParser->yyidxMax;
+}
+#endif
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_shift_action(
+  yyParser *pParser,        /* The parser */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
+){
+  int i;
+  int stateno = pParser->yystack[pParser->yyidx].stateno;
+ 
+  if( stateno>YY_SHIFT_COUNT
+   || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
+    return yy_default[stateno];
+  }
+  assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+    if( iLookAhead>0 ){
+#ifdef YYFALLBACK
+      YYCODETYPE iFallback;            /* Fallback token */
+      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+             && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+        }
+#endif
+        return yy_find_shift_action(pParser, iFallback);
+      }
+#endif
+#ifdef YYWILDCARD
+      {
+        int j = i - iLookAhead + YYWILDCARD;
+        if( 
+#if YY_SHIFT_MIN+YYWILDCARD<0
+          j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+          j<YY_ACTTAB_COUNT &&
+#endif
+          yy_lookahead[j]==YYWILDCARD
+        ){
+#ifndef NDEBUG
+          if( yyTraceFILE ){
+            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+               yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
+          }
+#endif /* NDEBUG */
+          return yy_action[j];
+        }
+      }
+#endif /* YYWILDCARD */
+    }
+    return yy_default[stateno];
+  }else{
+    return yy_action[i];
+  }
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+**
+** If the look-ahead token is YYNOCODE, then check to see if the action is
+** independent of the look-ahead.  If it is, return the action, otherwise
+** return YY_NO_ACTION.
+*/
+static int yy_find_reduce_action(
+  int stateno,              /* Current state number */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
+){
+  int i;
+#ifdef YYERRORSYMBOL
+  if( stateno>YY_REDUCE_COUNT ){
+    return yy_default[stateno];
+  }
+#else
+  assert( stateno<=YY_REDUCE_COUNT );
+#endif
+  i = yy_reduce_ofst[stateno];
+  assert( i!=YY_REDUCE_USE_DFLT );
+  assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+#ifdef YYERRORSYMBOL
+  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+    return yy_default[stateno];
+  }
+#else
+  assert( i>=0 && i<YY_ACTTAB_COUNT );
+  assert( yy_lookahead[i]==iLookAhead );
+#endif
+  return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
+   ParseARG_FETCH;
+   yypParser->yyidx--;
+#ifndef NDEBUG
+   if( yyTraceFILE ){
+     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+   }
+#endif
+   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+   /* Here code is inserted which will execute if the parser
+   ** stack every overflows */
+%%
+   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
+}
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+  yyParser *yypParser,          /* The parser to be shifted */
+  int yyNewState,               /* The new state to shift in */
+  int yyMajor,                  /* The major token to shift in */
+  YYMINORTYPE *yypMinor         /* Pointer to the minor token to shift in */
+){
+  yyStackEntry *yytos;
+  yypParser->yyidx++;
+#ifdef YYTRACKMAXSTACKDEPTH
+  if( yypParser->yyidx>yypParser->yyidxMax ){
+    yypParser->yyidxMax = yypParser->yyidx;
+  }
+#endif
+#if YYSTACKDEPTH>0 
+  if( yypParser->yyidx>=YYSTACKDEPTH ){
+    yyStackOverflow(yypParser, yypMinor);
+    return;
+  }
+#else
+  if( yypParser->yyidx>=yypParser->yystksz ){
+    yyGrowStack(yypParser);
+    if( yypParser->yyidx>=yypParser->yystksz ){
+      yyStackOverflow(yypParser, yypMinor);
+      return;
+    }
+  }
+#endif
+  yytos = &yypParser->yystack[yypParser->yyidx];
+  yytos->stateno = (YYACTIONTYPE)yyNewState;
+  yytos->major = (YYCODETYPE)yyMajor;
+  yytos->minor = *yypMinor;
+#ifndef NDEBUG
+  if( yyTraceFILE && yypParser->yyidx>0 ){
+    int i;
+    fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
+    fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
+    for(i=1; i<=yypParser->yyidx; i++)
+      fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
+    fprintf(yyTraceFILE,"\n");
+  }
+#endif
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+  YYCODETYPE lhs;         /* Symbol on the left-hand side of the rule */
+  unsigned char nrhs;     /* Number of right-hand side symbols in the rule */
+} yyRuleInfo[] = {
+%%
+};
+
+static void yy_accept(yyParser*);  /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+static void yy_reduce(
+  yyParser *yypParser,         /* The parser */
+  int yyruleno                 /* Number of the rule by which to reduce */
+){
+  int yygoto;                     /* The next state */
+  int yyact;                      /* The next action */
+  YYMINORTYPE yygotominor;        /* The LHS of the rule reduced */
+  yyStackEntry *yymsp;            /* The top of the parser's stack */
+  int yysize;                     /* Amount to pop the stack */
+  ParseARG_FETCH;
+  yymsp = &yypParser->yystack[yypParser->yyidx];
+#ifndef NDEBUG
+  if( yyTraceFILE && yyruleno>=0 
+        && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
+    fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
+      yyRuleName[yyruleno]);
+  }
+#endif /* NDEBUG */
+
+  /* Silence complaints from purify about yygotominor being uninitialized
+  ** in some cases when it is copied into the stack after the following
+  ** switch.  yygotominor is uninitialized when a rule reduces that does
+  ** not set the value of its left-hand side nonterminal.  Leaving the
+  ** value of the nonterminal uninitialized is utterly harmless as long
+  ** as the value is never used.  So really the only thing this code
+  ** accomplishes is to quieten purify.  
+  **
+  ** 2007-01-16:  The wireshark project (www.wireshark.org) reports that
+  ** without this code, their parser segfaults.  I'm not sure what there
+  ** parser is doing to make this happen.  This is the second bug report
+  ** from wireshark this week.  Clearly they are stressing Lemon in ways
+  ** that it has not been previously stressed...  (SQLite ticket #2172)
+  */
+  /*memset(&yygotominor, 0, sizeof(yygotominor));*/
+  yygotominor = yyzerominor;
+
+
+  switch( yyruleno ){
+  /* Beginning here are the reduction cases.  A typical example
+  ** follows:
+  **   case 0:
+  **  #line <lineno> <grammarfile>
+  **     { ... }           // User supplied code
+  **  #line <lineno> <thisfile>
+  **     break;
+  */
+%%
+  };
+  yygoto = yyRuleInfo[yyruleno].lhs;
+  yysize = yyRuleInfo[yyruleno].nrhs;
+  yypParser->yyidx -= yysize;
+  yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
+  if( yyact < YYNSTATE ){
+#ifdef NDEBUG
+    /* If we are not debugging and the reduce action popped at least
+    ** one element off the stack, then we can push the new element back
+    ** onto the stack here, and skip the stack overflow test in yy_shift().
+    ** That gives a significant speed improvement. */
+    if( yysize ){
+      yypParser->yyidx++;
+      yymsp -= yysize-1;
+      yymsp->stateno = (YYACTIONTYPE)yyact;
+      yymsp->major = (YYCODETYPE)yygoto;
+      yymsp->minor = yygotominor;
+    }else
+#endif
+    {
+      yy_shift(yypParser,yyact,yygoto,&yygotominor);
+    }
+  }else{
+    assert( yyact == YYNSTATE + YYNRULE + 1 );
+    yy_accept(yypParser);
+  }
+}
+
+/*
+** The following code executes when the parse fails
+*/
+#ifndef YYNOERRORRECOVERY
+static void yy_parse_failed(
+  yyParser *yypParser           /* The parser */
+){
+  ParseARG_FETCH;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
+  }
+#endif
+  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+  /* Here code is inserted which will be executed whenever the
+  ** parser fails */
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+#endif /* YYNOERRORRECOVERY */
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+static void yy_syntax_error(
+  yyParser *yypParser,           /* The parser */
+  int yymajor,                   /* The major type of the error token */
+  YYMINORTYPE yyminor            /* The minor type of the error token */
+){
+  ParseARG_FETCH;
+#define TOKEN (yyminor.yy0)
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+static void yy_accept(
+  yyParser *yypParser           /* The parser */
+){
+  ParseARG_FETCH;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
+  }
+#endif
+  while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
+  /* Here code is inserted which will be executed whenever the
+  ** parser accepts */
+%%
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "ParseAlloc" which describes the current state of the parser.
+** The second argument is the major token number.  The third is
+** the minor token.  The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void Parse(
+  void *yyp,                   /* The parser */
+  int yymajor,                 /* The major token code number */
+  ParseTOKENTYPE yyminor       /* The value for the token */
+  ParseARG_PDECL               /* Optional %extra_argument parameter */
+){
+  YYMINORTYPE yyminorunion;
+  int yyact;            /* The parser action. */
+  int yyendofinput;     /* True if we are at the end of input */
+#ifdef YYERRORSYMBOL
+  int yyerrorhit = 0;   /* True if yymajor has invoked an error */
+#endif
+  yyParser *yypParser;  /* The parser */
+
+  /* (re)initialize the parser, if necessary */
+  yypParser = (yyParser*)yyp;
+  if( yypParser->yyidx<0 ){
+#if YYSTACKDEPTH<=0
+    if( yypParser->yystksz <=0 ){
+      /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
+      yyminorunion = yyzerominor;
+      yyStackOverflow(yypParser, &yyminorunion);
+      return;
+    }
+#endif
+    yypParser->yyidx = 0;
+    yypParser->yyerrcnt = -1;
+    yypParser->yystack[0].stateno = 0;
+    yypParser->yystack[0].major = 0;
+  }
+  yyminorunion.yy0 = yyminor;
+  yyendofinput = (yymajor==0);
+  ParseARG_STORE;
+
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
+  }
+#endif
+
+  do{
+    yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
+    if( yyact<YYNSTATE ){
+      assert( !yyendofinput );  /* Impossible to shift the $ token */
+      yy_shift(yypParser,yyact,yymajor,&yyminorunion);
+      yypParser->yyerrcnt--;
+      yymajor = YYNOCODE;
+    }else if( yyact < YYNSTATE + YYNRULE ){
+      yy_reduce(yypParser,yyact-YYNSTATE);
+    }else{
+      assert( yyact == YY_ERROR_ACTION );
+#ifdef YYERRORSYMBOL
+      int yymx;
+#endif
+#ifndef NDEBUG
+      if( yyTraceFILE ){
+        fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
+      }
+#endif
+#ifdef YYERRORSYMBOL
+      /* A syntax error has occurred.
+      ** The response to an error depends upon whether or not the
+      ** grammar defines an error token "ERROR".  
+      **
+      ** This is what we do if the grammar does define ERROR:
+      **
+      **  * Call the %syntax_error function.
+      **
+      **  * Begin popping the stack until we enter a state where
+      **    it is legal to shift the error symbol, then shift
+      **    the error symbol.
+      **
+      **  * Set the error count to three.
+      **
+      **  * Begin accepting and shifting new tokens.  No new error
+      **    processing will occur until three tokens have been
+      **    shifted successfully.
+      **
+      */
+      if( yypParser->yyerrcnt<0 ){
+        yy_syntax_error(yypParser,yymajor,yyminorunion);
+      }
+      yymx = yypParser->yystack[yypParser->yyidx].major;
+      if( yymx==YYERRORSYMBOL || yyerrorhit ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE,"%sDiscard input token %s\n",
+             yyTracePrompt,yyTokenName[yymajor]);
+        }
+#endif
+        yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
+        yymajor = YYNOCODE;
+      }else{
+         while(
+          yypParser->yyidx >= 0 &&
+          yymx != YYERRORSYMBOL &&
+          (yyact = yy_find_reduce_action(
+                        yypParser->yystack[yypParser->yyidx].stateno,
+                        YYERRORSYMBOL)) >= YYNSTATE
+        ){
+          yy_pop_parser_stack(yypParser);
+        }
+        if( yypParser->yyidx < 0 || yymajor==0 ){
+          yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+          yy_parse_failed(yypParser);
+          yymajor = YYNOCODE;
+        }else if( yymx!=YYERRORSYMBOL ){
+          YYMINORTYPE u2;
+          u2.YYERRSYMDT = 0;
+          yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
+        }
+      }
+      yypParser->yyerrcnt = 3;
+      yyerrorhit = 1;
+#elif defined(YYNOERRORRECOVERY)
+      /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+      ** do any kind of error recovery.  Instead, simply invoke the syntax
+      ** error routine and continue going as if nothing had happened.
+      **
+      ** Applications can set this macro (for example inside %include) if
+      ** they intend to abandon the parse upon the first syntax error seen.
+      */
+      yy_syntax_error(yypParser,yymajor,yyminorunion);
+      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+      yymajor = YYNOCODE;
+      
+#else  /* YYERRORSYMBOL is not defined */
+      /* This is what we do if the grammar does not define ERROR:
+      **
+      **  * Report an error message, and throw away the input token.
+      **
+      **  * If the input token is $, then fail the parse.
+      **
+      ** As before, subsequent error messages are suppressed until
+      ** three input tokens have been successfully shifted.
+      */
+      if( yypParser->yyerrcnt<=0 ){
+        yy_syntax_error(yypParser,yymajor,yyminorunion);
+      }
+      yypParser->yyerrcnt = 3;
+      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+      if( yyendofinput ){
+        yy_parse_failed(yypParser);
+      }
+      yymajor = YYNOCODE;
+#endif
+    }
+  }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
+  return;
+}

luci-base/src/jsmin.c

@@ -0,0 +1,319 @@
+/* jsmin.c
+   2019-10-30
+
+Copyright (C) 2002 Douglas Crockford  (www.crockford.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+
+static int the_a;
+static int the_b;
+static int look_ahead = EOF;
+static int the_x = EOF;
+static int the_y = EOF;
+
+
+static void error(char* string) {
+    fputs("JSMIN Error: ", stderr);
+    fputs(string, stderr);
+    fputc('\n', stderr);
+    exit(1);
+}
+
+/* is_alphanum -- return true if the character is a letter, digit, underscore,
+        dollar sign, or non-ASCII character.
+*/
+
+static int is_alphanum(int codeunit) {
+    return (
+        (codeunit >= 'a' && codeunit <= 'z')
+        || (codeunit >= '0' && codeunit <= '9')
+        || (codeunit >= 'A' && codeunit <= 'Z')
+        || codeunit == '_'
+        || codeunit == '$'
+        || codeunit == '\\'
+        || codeunit > 126
+    );
+}
+
+
+/* get -- return the next character from stdin. Watch out for lookahead. If
+        the character is a control character, translate it to a space or
+        linefeed.
+*/
+
+static int get() {
+    int codeunit = look_ahead;
+    look_ahead = EOF;
+    if (codeunit == EOF) {
+        codeunit = getc(stdin);
+    }
+    if (codeunit >= ' ' || codeunit == '\n' || codeunit == EOF) {
+        return codeunit;
+    }
+    if (codeunit == '\r') {
+        return '\n';
+    }
+    return ' ';
+}
+
+
+/* peek -- get the next character without advancing.
+*/
+
+static int peek() {
+    look_ahead = get();
+    return look_ahead;
+}
+
+
+/* next -- get the next character, excluding comments. peek() is used to see
+        if a '/' is followed by a '/' or '*'.
+*/
+
+static int next() {
+    int codeunit = get();
+    if  (codeunit == '/') {
+        switch (peek()) {
+        case '/':
+            for (;;) {
+                codeunit = get();
+                if (codeunit <= '\n') {
+                    break;
+                }
+            }
+            break;
+        case '*':
+            get();
+            while (codeunit != ' ') {
+                switch (get()) {
+                case '*':
+                    if (peek() == '/') {
+                        get();
+                        codeunit = ' ';
+                    }
+                    break;
+                case EOF:
+                    error("Unterminated comment.");
+                }
+            }
+            break;
+        }
+    }
+    the_y = the_x;
+    the_x = codeunit;
+    return codeunit;
+}
+
+
+/* action -- do something! What you do is determined by the argument:
+        1   Output A. Copy B to A. Get the next B.
+        2   Copy B to A. Get the next B. (Delete A).
+        3   Get the next B. (Delete B).
+   action treats a string as a single character.
+   action recognizes a regular expression if it is preceded by the likes of
+   '(' or ',' or '='.
+*/
+
+static void action(int determined) {
+    switch (determined) {
+    case 1:
+        putc(the_a, stdout);
+        if (
+            (the_y == '\n' || the_y == ' ')
+            && (the_a == '+' || the_a == '-' || the_a == '*' || the_a == '/')
+            && (the_b == '+' || the_b == '-' || the_b == '*' || the_b == '/')
+        ) {
+            putc(the_y, stdout);
+        }
+    case 2:
+        the_a = the_b;
+        if (the_a == '\'' || the_a == '"' || the_a == '`') {
+            for (;;) {
+                putc(the_a, stdout);
+                the_a = get();
+                if (the_a == the_b) {
+                    break;
+                }
+                if (the_a == '\\') {
+                    putc(the_a, stdout);
+                    the_a = get();
+                }
+                if (the_a == EOF) {
+                    error("Unterminated string literal.");
+                }
+            }
+        }
+    case 3:
+        the_b = next();
+        if (the_b == '/' && (
+            the_a == '(' || the_a == ',' || the_a == '=' || the_a == ':'
+            || the_a == '[' || the_a == '!' || the_a == '&' || the_a == '|'
+            || the_a == '?' || the_a == '+' || the_a == '-' || the_a == '~'
+            || the_a == '*' || the_a == '/' || the_a == '{' || the_a == '}'
+            || the_a == ';'
+        )) {
+            putc(the_a, stdout);
+            if (the_a == '/' || the_a == '*') {
+                putc(' ', stdout);
+            }
+            putc(the_b, stdout);
+            for (;;) {
+                the_a = get();
+                if (the_a == '[') {
+                    for (;;) {
+                        putc(the_a, stdout);
+                        the_a = get();
+                        if (the_a == ']') {
+                            break;
+                        }
+                        if (the_a == '\\') {
+                            putc(the_a, stdout);
+                            the_a = get();
+                        }
+                        if (the_a == EOF) {
+                            error(
+                                "Unterminated set in Regular Expression literal."
+                            );
+                        }
+                    }
+                } else if (the_a == '/') {
+                    switch (peek()) {
+                    case '/':
+                    case '*':
+                        error(
+                            "Unterminated set in Regular Expression literal."
+                        );
+                    }
+                    break;
+                } else if (the_a =='\\') {
+                    putc(the_a, stdout);
+                    the_a = get();
+                }
+                if (the_a == EOF) {
+                    error("Unterminated Regular Expression literal.");
+                }
+                putc(the_a, stdout);
+            }
+            the_b = next();
+        }
+    }
+}
+
+
+/* jsmin -- Copy the input to the output, deleting the characters which are
+        insignificant to JavaScript. Comments will be removed. Tabs will be
+        replaced with spaces. Carriage returns will be replaced with linefeeds.
+        Most spaces and linefeeds will be removed.
+*/
+
+static void jsmin() {
+    if (peek() == 0xEF) {
+        get();
+        get();
+        get();
+    }
+    the_a = '\n';
+    action(3);
+    while (the_a != EOF) {
+        switch (the_a) {
+        case ' ':
+            action(
+                is_alphanum(the_b)
+                ? 1
+                : 2
+            );
+            break;
+        case '\n':
+            switch (the_b) {
+            case '{':
+            case '[':
+            case '(':
+            case '+':
+            case '-':
+            case '!':
+            case '~':
+                action(1);
+                break;
+            case ' ':
+                action(3);
+                break;
+            default:
+                action(
+                    is_alphanum(the_b)
+                    ? 1
+                    : 2
+                );
+            }
+            break;
+        default:
+            switch (the_b) {
+            case ' ':
+                action(
+                    is_alphanum(the_a)
+                    ? 1
+                    : 3
+                );
+                break;
+            case '\n':
+                switch (the_a) {
+                case '}':
+                case ']':
+                case ')':
+                case '+':
+                case '-':
+                case '"':
+                case '\'':
+                case '`':
+                    action(1);
+                    break;
+                default:
+                    action(
+                        is_alphanum(the_a)
+                        ? 1
+                        : 3
+                    );
+                }
+                break;
+            default:
+                action(1);
+                break;
+            }
+        }
+    }
+}
+
+
+/* main -- Output any command line arguments as comments
+        and then minify the input.
+*/
+
+extern int main(int argc, char* argv[]) {
+    int i;
+    for (i = 1; i < argc; i += 1) {
+        fprintf(stdout, "// %s\n", argv[i]);
+    }
+    jsmin();
+    return 0;
+}

luci-base/src/lib/lmo.c

@@ -0,0 +1,636 @@
+/*
+ * lmo - Lua Machine Objects - Base functions
+ *
+ *   Copyright (C) 2009-2010 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "lmo.h"
+#include "plural_formula.h"
+
+/*
+ * Hash function from http://www.azillionmonkeys.com/qed/hash.html
+ * Copyright (C) 2004-2008 by Paul Hsieh
+ */
+
+uint32_t sfh_hash(const char *data, size_t len, uint32_t init)
+{
+	uint32_t hash = init, tmp;
+	int rem;
+
+	if (len <= 0 || data == NULL) return 0;
+
+	rem = len & 3;
+	len >>= 2;
+
+	/* Main loop */
+	for (;len > 0; len--) {
+		hash  += sfh_get16(data);
+		tmp    = (sfh_get16(data+2) << 11) ^ hash;
+		hash   = (hash << 16) ^ tmp;
+		data  += 2*sizeof(uint16_t);
+		hash  += hash >> 11;
+	}
+
+	/* Handle end cases */
+	switch (rem) {
+		case 3: hash += sfh_get16(data);
+			hash ^= hash << 16;
+			hash ^= (signed char)data[sizeof(uint16_t)] << 18;
+			hash += hash >> 11;
+			break;
+		case 2: hash += sfh_get16(data);
+			hash ^= hash << 11;
+			hash += hash >> 17;
+			break;
+		case 1: hash += (signed char)*data;
+			hash ^= hash << 10;
+			hash += hash >> 1;
+	}
+
+	/* Force "avalanching" of final 127 bits */
+	hash ^= hash << 3;
+	hash += hash >> 5;
+	hash ^= hash << 4;
+	hash += hash >> 17;
+	hash ^= hash << 25;
+	hash += hash >> 6;
+
+	return hash;
+}
+
+uint32_t lmo_canon_hash(const char *str, int len,
+                        const char *ctx, int ctxlen, int plural)
+{
+	char res[4096];
+	char *ptr, *end, prev;
+	int off;
+
+	if (!str)
+		return 0;
+
+	ptr = res;
+	end = res + sizeof(res);
+
+	if (ctx)
+	{
+		for (prev = ' ', off = 0; off < ctxlen; prev = *ctx, off++, ctx++)
+		{
+			if (ptr >= end)
+				return 0;
+
+			if (isspace(*ctx))
+			{
+				if (!isspace(prev))
+					*ptr++ = ' ';
+			}
+			else
+			{
+				*ptr++ = *ctx;
+			}
+		}
+
+		if ((ptr > res) && isspace(*(ptr-1)))
+			ptr--;
+
+		if (ptr >= end)
+			return 0;
+
+		*ptr++ = '\1';
+	}
+
+	for (prev = ' ', off = 0; off < len; prev = *str, off++, str++)
+	{
+		if (ptr >= end)
+			return 0;
+
+		if (isspace(*str))
+		{
+			if (!isspace(prev))
+				*ptr++ = ' ';
+		}
+		else
+		{
+			*ptr++ = *str;
+		}
+	}
+
+	if ((ptr > res) && isspace(*(ptr-1)))
+		ptr--;
+
+	if (plural > -1)
+	{
+		if (plural >= 100 || ptr + 3 >= end)
+			return 0;
+
+		ptr += snprintf(ptr, 3, "\2%d", plural);
+	}
+
+	return sfh_hash(res, ptr - res, ptr - res);
+}
+
+lmo_archive_t * lmo_open(const char *file)
+{
+	int in = -1;
+	uint32_t idx_offset = 0;
+	struct stat s;
+
+	lmo_archive_t *ar = NULL;
+
+	if (stat(file, &s) == -1)
+		goto err;
+
+	if ((in = open(file, O_RDONLY)) == -1)
+		goto err;
+
+	if ((ar = (lmo_archive_t *)malloc(sizeof(*ar))) != NULL)
+	{
+		memset(ar, 0, sizeof(*ar));
+
+		ar->fd     = in;
+		ar->size = s.st_size;
+
+		fcntl(ar->fd, F_SETFD, fcntl(ar->fd, F_GETFD) | FD_CLOEXEC);
+
+		if ((ar->mmap = mmap(NULL, ar->size, PROT_READ, MAP_SHARED, ar->fd, 0)) == MAP_FAILED)
+			goto err;
+
+		idx_offset = ntohl(*((const uint32_t *)
+		                     (ar->mmap + ar->size - sizeof(uint32_t))));
+
+		if (idx_offset >= ar->size)
+			goto err;
+
+		ar->index  = (lmo_entry_t *)(ar->mmap + idx_offset);
+		ar->length = (ar->size - idx_offset - sizeof(uint32_t)) / sizeof(lmo_entry_t);
+		ar->end    = ar->mmap + ar->size;
+
+		return ar;
+	}
+
+err:
+	if (in > -1)
+		close(in);
+
+	if (ar != NULL)
+	{
+		if ((ar->mmap != NULL) && (ar->mmap != MAP_FAILED))
+			munmap(ar->mmap, ar->size);
+
+		free(ar);
+	}
+
+	return NULL;
+}
+
+void lmo_close(lmo_archive_t *ar)
+{
+	if (ar != NULL)
+	{
+		if ((ar->mmap != NULL) && (ar->mmap != MAP_FAILED))
+			munmap(ar->mmap, ar->size);
+
+		close(ar->fd);
+		free(ar);
+
+		ar = NULL;
+	}
+}
+
+
+lmo_catalog_t *_lmo_catalogs = NULL;
+lmo_catalog_t *_lmo_active_catalog = NULL;
+
+int lmo_load_catalog(const char *lang, const char *dir)
+{
+	DIR *dh = NULL;
+	char pattern[16];
+	char path[PATH_MAX];
+	struct dirent *de = NULL;
+
+	lmo_archive_t *ar = NULL;
+	lmo_catalog_t *cat = NULL;
+
+	if (!lmo_change_catalog(lang))
+		return 0;
+
+	if (!dir || !(dh = opendir(dir)))
+		goto err;
+
+	if (!(cat = malloc(sizeof(*cat))))
+		goto err;
+
+	memset(cat, 0, sizeof(*cat));
+
+	snprintf(cat->lang, sizeof(cat->lang), "%s", lang);
+	snprintf(pattern, sizeof(pattern), "*.%s.lmo", lang);
+
+	while ((de = readdir(dh)) != NULL)
+	{
+		if (!fnmatch(pattern, de->d_name, 0))
+		{
+			snprintf(path, sizeof(path), "%s/%s", dir, de->d_name);
+			ar = lmo_open(path);
+
+			if (ar)
+			{
+				ar->next = cat->archives;
+				cat->archives = ar;
+			}
+		}
+	}
+
+	closedir(dh);
+
+	cat->next = _lmo_catalogs;
+	_lmo_catalogs = cat;
+
+	if (!_lmo_active_catalog)
+		_lmo_active_catalog = cat;
+
+	return cat->archives ? 0 : -1;
+
+err:
+	if (dh) closedir(dh);
+	if (cat) free(cat);
+
+	return -1;
+}
+
+int lmo_change_catalog(const char *lang)
+{
+	lmo_catalog_t *cat;
+
+	for (cat = _lmo_catalogs; cat; cat = cat->next)
+	{
+		if (!strncmp(cat->lang, lang, sizeof(cat->lang)))
+		{
+			_lmo_active_catalog = cat;
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+static lmo_entry_t * lmo_find_entry(lmo_archive_t *ar, uint32_t hash)
+{
+	unsigned int m, l, r;
+	uint32_t k;
+
+	l = 0;
+	r = ar->length - 1;
+
+	while (1)
+	{
+		m = l + ((r - l) / 2);
+
+		if (r < l)
+			break;
+
+		k = ntohl(ar->index[m].key_id);
+
+		if (k == hash)
+			return &ar->index[m];
+
+		if (k > hash)
+		{
+			if (!m)
+				break;
+
+			r = m - 1;
+		}
+		else
+		{
+			l = m + 1;
+		}
+	}
+
+	return NULL;
+}
+
+void *pluralParseAlloc(void *(*)(size_t));
+void pluralParse(void *, int, int, void *);
+void pluralParseFree(void *, void (*)(void *));
+
+static int lmo_eval_plural(const char *expr, int len, int val)
+{
+	struct { int num; int res; } s = { .num = val, .res = -1 };
+	const char *p = NULL;
+	void *pParser = NULL;
+	int t, n;
+	char c;
+
+	while (len > 7) {
+		if (*expr == 'p') {
+			if (!strncmp(expr, "plural=", 7)) {
+				p = expr + 7;
+				len -= 7;
+				break;
+			}
+		}
+
+		expr++;
+		len--;
+	}
+
+	if (!p)
+		goto out;
+
+	pParser = pluralParseAlloc(malloc);
+
+	if (!pParser)
+		goto out;
+
+	while (len-- > 0) {
+		c = *p++;
+		t = -1;
+		n = 0;
+
+		switch (c) {
+		case ' ':
+		case '\t':
+			continue;
+
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+			t = T_NUM;
+			n = c - '0';
+
+			while (*p >= '0' && *p <= '9') {
+				n *= 10;
+				n += *p - '0';
+				p++;
+			}
+
+			break;
+
+		case '=':
+			if (*p == '=') {
+				t = T_EQ;
+				p++;
+			}
+
+			break;
+
+		case '!':
+			if (*p == '=') {
+				t = T_NE;
+				p++;
+			}
+			else {
+				t = T_NOT;
+			}
+
+			break;
+
+		case '&':
+			if (*p == '&') {
+				t = T_AND;
+				p++;
+			}
+
+			break;
+
+		case '|':
+			if (*p == '|') {
+				t = T_OR;
+				p++;
+			}
+
+			break;
+
+		case '<':
+			if (*p == '=') {
+				t = T_LE;
+				p++;
+			}
+			else {
+				t = T_LT;
+			}
+
+			break;
+
+		case '>':
+			if (*p == '=') {
+				t = T_GE;
+				p++;
+			}
+			else {
+				t = T_GT;
+			}
+
+			break;
+
+		case '*':
+			t = T_MUL;
+			break;
+
+		case '/':
+			t = T_DIV;
+			break;
+
+		case '%':
+			t = T_MOD;
+			break;
+
+		case '+':
+			t = T_ADD;
+			break;
+
+		case '-':
+			t = T_SUB;
+			break;
+
+		case 'n':
+			t = T_N;
+			break;
+
+		case '?':
+			t = T_QMARK;
+			break;
+
+		case ':':
+			t = T_COLON;
+			break;
+
+		case '(':
+			t = T_LPAREN;
+			break;
+
+		case ')':
+			t = T_RPAREN;
+			break;
+
+		case ';':
+		case '\n':
+		case '\0':
+			t = 0;
+			break;
+		}
+
+		/* syntax error */
+		if (t < 0)
+			goto out;
+
+		pluralParse(pParser, t, n, &s);
+
+		/* eof */
+		if (t == 0)
+			break;
+	}
+
+	pluralParse(pParser, 0, 0, &s);
+
+out:
+	pluralParseFree(pParser, free);
+
+	return s.res;
+}
+
+int lmo_translate(const char *key, int keylen, char **out, int *outlen)
+{
+	return lmo_translate_ctxt(key, keylen, NULL, 0, out, outlen);
+}
+
+int lmo_translate_ctxt(const char *key, int keylen,
+                       const char *ctx, int ctxlen,
+                       char **out, int *outlen)
+{
+	uint32_t hash;
+	lmo_entry_t *e;
+	lmo_archive_t *ar;
+
+	if (!key || !_lmo_active_catalog)
+		return -2;
+
+	hash = lmo_canon_hash(key, keylen, ctx, ctxlen, -1);
+
+	if (hash > 0)
+	{
+		for (ar = _lmo_active_catalog->archives; ar; ar = ar->next)
+		{
+			if ((e = lmo_find_entry(ar, hash)) != NULL)
+			{
+				*out = ar->mmap + ntohl(e->offset);
+				*outlen = ntohl(e->length);
+				return 0;
+			}
+		}
+	}
+
+	return -1;
+}
+
+int lmo_translate_plural(int n, const char *skey, int skeylen,
+                                const char *pkey, int pkeylen,
+                                char **out, int *outlen)
+{
+	return lmo_translate_plural_ctxt(n, skey, skeylen, pkey, pkeylen,
+	                                 NULL, 0, out, outlen);
+}
+
+int lmo_translate_plural_ctxt(int n, const char *skey, int skeylen,
+                                     const char *pkey, int pkeylen,
+                                     const char *ctx, int ctxlen,
+                                     char **out, int *outlen)
+{
+	int pid = -1;
+	uint32_t hash;
+	lmo_entry_t *e;
+	lmo_archive_t *ar;
+
+	if (!skey || !pkey || !_lmo_active_catalog)
+		return -2;
+
+	for (ar = _lmo_active_catalog->archives; ar; ar = ar->next) {
+		e = lmo_find_entry(ar, 0);
+
+		if (e != NULL) {
+			pid = lmo_eval_plural(ar->mmap + ntohl(e->offset), ntohl(e->length), n);
+			break;
+		}
+	}
+
+	if (pid == -1)
+		pid = (n != 1);
+
+	hash = lmo_canon_hash(skey, skeylen, ctx, ctxlen, pid);
+
+	if (hash == 0)
+		return -1;
+
+	for (ar = _lmo_active_catalog->archives; ar; ar = ar->next)
+	{
+		if ((e = lmo_find_entry(ar, hash)) != NULL)
+		{
+			*out = ar->mmap + ntohl(e->offset);
+			*outlen = ntohl(e->length);
+			return 0;
+		}
+	}
+
+	if (n != 1)
+	{
+		*out = (char *)pkey;
+		*outlen = pkeylen;
+	}
+	else
+	{
+		*out = (char *)skey;
+		*outlen = skeylen;
+	}
+
+	return 0;
+}
+
+void lmo_iterate(lmo_iterate_cb_t cb, void *priv)
+{
+	unsigned int i;
+	lmo_entry_t *e;
+	lmo_archive_t *ar;
+
+	if (!_lmo_active_catalog)
+		return;
+
+	for (ar = _lmo_active_catalog->archives; ar; ar = ar->next)
+		for (i = 0, e = &ar->index[0]; i < ar->length; e = &ar->index[++i])
+			cb(ntohl(e->key_id), ar->mmap + ntohl(e->offset), ntohl(e->length), priv);
+}
+
+void lmo_close_catalog(const char *lang)
+{
+	lmo_archive_t *ar, *next;
+	lmo_catalog_t *cat, *prev;
+
+	for (prev = NULL, cat = _lmo_catalogs; cat; prev = cat, cat = cat->next)
+	{
+		if (!strncmp(cat->lang, lang, sizeof(cat->lang)))
+		{
+			if (prev)
+				prev->next = cat->next;
+			else
+				_lmo_catalogs = cat->next;
+
+			for (ar = cat->archives; ar; ar = next)
+			{
+				next = ar->next;
+				lmo_close(ar);
+			}
+
+			free(cat);
+			break;
+		}
+	}
+}

luci-base/src/lib/lmo.h

@@ -0,0 +1,108 @@
+/*
+ * lmo - Lua Machine Objects - General header
+ *
+ *   Copyright (C) 2009-2012 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef _TEMPLATE_LMO_H_
+#define _TEMPLATE_LMO_H_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fnmatch.h>
+#include <dirent.h>
+#include <ctype.h>
+#include <limits.h>
+
+#if (defined(__GNUC__) && defined(__i386__))
+#define sfh_get16(d) (*((const uint16_t *) (d)))
+#else
+#define sfh_get16(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
+					   +(uint32_t)(((const uint8_t *)(d))[0]) )
+#endif
+
+#ifndef __hidden
+#define __hidden __attribute__((visibility("hidden")))
+#endif
+
+
+struct lmo_entry {
+	uint32_t key_id;
+	uint32_t val_id;
+	uint32_t offset;
+	uint32_t length;
+} __attribute__((packed));
+
+typedef struct lmo_entry lmo_entry_t;
+
+
+struct lmo_archive {
+	int         fd;
+	int	        length;
+	uint32_t    size;
+	lmo_entry_t *index;
+	char        *mmap;
+	char		*end;
+	struct lmo_archive *next;
+};
+
+typedef struct lmo_archive lmo_archive_t;
+
+
+struct lmo_catalog {
+	char lang[6];
+	struct lmo_archive *archives;
+	struct lmo_catalog *next;
+};
+
+typedef struct lmo_catalog lmo_catalog_t;
+
+typedef void (*lmo_iterate_cb_t)(uint32_t, const char *, int, void *);
+
+__hidden uint32_t sfh_hash(const char *data, size_t len, uint32_t init);
+__hidden uint32_t lmo_canon_hash(const char *data, int len,
+                                 const char *ctx, int ctxlen, int plural);
+
+__hidden lmo_archive_t * lmo_open(const char *file);
+__hidden void lmo_close(lmo_archive_t *ar);
+
+
+__hidden extern lmo_catalog_t *_lmo_catalogs;
+__hidden extern lmo_catalog_t *_lmo_active_catalog;
+
+__hidden int lmo_load_catalog(const char *lang, const char *dir);
+__hidden int lmo_change_catalog(const char *lang);
+__hidden int lmo_translate(const char *key, int keylen, char **out, int *outlen);
+__hidden int lmo_translate_ctxt(const char *key, int keylen,
+                                const char *ctx, int ctxlen, char **out, int *outlen);
+__hidden int lmo_translate_plural(int n, const char *skey, int skeylen,
+                                  const char *pkey, int pkeylen,
+                                  char **out, int *outlen);
+__hidden int lmo_translate_plural_ctxt(int n, const char *skey, int skeylen,
+                                       const char *pkey, int pkeylen,
+                                       const char *ctx, int ctxlen,
+                                     char **out, int *outlen);
+__hidden void lmo_iterate(lmo_iterate_cb_t cb, void *priv);
+__hidden void lmo_close_catalog(const char *lang);
+
+#endif

luci-base/src/lib/luci.c

@@ -0,0 +1,383 @@
+/*
+ * LuCI low level routines - ucode binding
+ *
+ *   Copyright (C) 2009-2022 Jo-Philipp Wich <jo@mein.io>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "lmo.h"
+
+#include <pwd.h>
+#include <crypt.h>
+#include <shadow.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <sys/sysinfo.h>
+#include <sys/statvfs.h>
+
+#include <ucode/module.h>
+
+/* translation catalog functions */
+
+static uc_value_t *
+uc_luci_load_catalog(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *lang = uc_fn_arg(0);
+	uc_value_t *dir  = uc_fn_arg(1);
+
+	if (lang && ucv_type(lang) != UC_STRING)
+		return NULL;
+
+	if (dir && ucv_type(dir) != UC_STRING)
+		return NULL;
+
+	return ucv_boolean_new(lmo_load_catalog(
+		lang ? ucv_string_get(lang) : "en",
+		ucv_string_get(dir)) == 0);
+}
+
+static uc_value_t *
+uc_luci_close_catalog(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *lang = uc_fn_arg(0);
+
+	if (lang && ucv_type(lang) != UC_STRING)
+		return NULL;
+
+	lmo_close_catalog(lang ? ucv_string_get(lang) : "en");
+
+	return ucv_boolean_new(true);
+}
+
+static uc_value_t *
+uc_luci_change_catalog(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *lang = uc_fn_arg(0);
+
+	if (lang && ucv_type(lang) != UC_STRING)
+		return NULL;
+
+	return ucv_boolean_new(lmo_change_catalog(
+		lang ? ucv_string_get(lang) : "en") == 0);
+}
+
+static void
+uc_luci_get_translations_cb(uint32_t key, const char *val, int len, void *priv) {
+	uc_vm_t *vm = priv;
+
+	uc_vm_stack_push(vm, ucv_get(uc_vm_stack_peek(vm, 0)));
+	uc_vm_stack_push(vm, ucv_uint64_new(key));
+	uc_vm_stack_push(vm, ucv_string_new_length(val, (size_t)len));
+
+	if (uc_vm_call(vm, false, 2) == EXCEPTION_NONE)
+		ucv_put(uc_vm_stack_pop(vm));
+}
+
+static uc_value_t *
+uc_luci_get_translations(uc_vm_t *vm, size_t nargs) {
+	lmo_iterate(uc_luci_get_translations_cb, vm);
+
+	return ucv_boolean_new(true);
+}
+
+static uc_value_t *
+uc_luci_translate(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *key = uc_fn_arg(0);
+	uc_value_t *ctx = uc_fn_arg(1);
+	int trlen;
+	char *tr;
+
+	if (ucv_type(key) != UC_STRING)
+		return NULL;
+
+	if (ctx && ucv_type(ctx) != UC_STRING)
+		return NULL;
+
+	if (lmo_translate_ctxt(ucv_string_get(key), ucv_string_length(key),
+	                       ucv_string_get(ctx), ucv_string_length(ctx),
+	                       &tr, &trlen) != 0)
+		return NULL;
+
+	return ucv_string_new_length(tr, (size_t)trlen);
+}
+
+static uc_value_t *
+uc_luci_ntranslate(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *cnt  = uc_fn_arg(0);
+	uc_value_t *skey = uc_fn_arg(1);
+	uc_value_t *pkey = uc_fn_arg(2);
+	uc_value_t *ctx  = uc_fn_arg(3);
+	int trlen;
+	char *tr;
+
+	if (ucv_type(skey) != UC_STRING || ucv_type(pkey) != UC_STRING)
+		return NULL;
+
+	if (ctx && ucv_type(ctx) != UC_STRING)
+		return NULL;
+
+	if (lmo_translate_plural_ctxt(ucv_int64_get(cnt),
+	                              ucv_string_get(skey), ucv_string_length(skey),
+	                              ucv_string_get(pkey), ucv_string_length(pkey),
+	                              ucv_string_get(ctx), ucv_string_length(ctx),
+	                              &tr, &trlen) != 0)
+		return NULL;
+
+	return ucv_string_new_length(tr, (size_t)trlen);
+}
+
+static uc_value_t *
+uc_luci_hash(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *key = uc_fn_arg(0);
+	uc_value_t *init = uc_fn_arg(1);
+
+	if (ucv_type(key) != UC_STRING)
+		return NULL;
+
+	if (init && ucv_type(init) != UC_INTEGER)
+		return NULL;
+
+	return ucv_uint64_new(sfh_hash(ucv_string_get(key), ucv_string_length(key),
+	                               init ? ucv_uint64_get(init) : ucv_string_length(key)));
+}
+
+
+/* user functions */
+
+static uc_value_t *
+uc_luci_getspnam(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *name = uc_fn_arg(0), *rv;
+	struct spwd *s;
+
+	if (ucv_type(name) != UC_STRING)
+		return NULL;
+
+	s = getspnam(ucv_string_get(name));
+
+	if (!s)
+		return NULL;
+
+	rv = ucv_object_new(vm);
+
+	ucv_object_add(rv, "namp", ucv_string_new(s->sp_namp));
+	ucv_object_add(rv, "pwdp", ucv_string_new(s->sp_pwdp));
+	ucv_object_add(rv, "lstchg", ucv_int64_new(s->sp_lstchg));
+	ucv_object_add(rv, "min", ucv_int64_new(s->sp_min));
+	ucv_object_add(rv, "max", ucv_int64_new(s->sp_max));
+	ucv_object_add(rv, "warn", ucv_int64_new(s->sp_warn));
+	ucv_object_add(rv, "inact", ucv_int64_new(s->sp_inact));
+	ucv_object_add(rv, "expire", ucv_int64_new(s->sp_expire));
+
+	return rv;
+}
+
+static uc_value_t *
+uc_luci_getpwnam(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *name = uc_fn_arg(0), *rv;
+	struct passwd *p;
+
+	if (ucv_type(name) != UC_STRING)
+		return NULL;
+
+	p = getpwnam(ucv_string_get(name));
+
+	if (!p)
+		return NULL;
+
+	rv = ucv_object_new(vm);
+
+	ucv_object_add(rv, "name", ucv_string_new(p->pw_name));
+	ucv_object_add(rv, "passwd", ucv_string_new(p->pw_passwd));
+	ucv_object_add(rv, "uid", ucv_int64_new(p->pw_uid));
+	ucv_object_add(rv, "gid", ucv_int64_new(p->pw_gid));
+	ucv_object_add(rv, "gecos", ucv_string_new(p->pw_gecos));
+	ucv_object_add(rv, "dir", ucv_string_new(p->pw_dir));
+	ucv_object_add(rv, "shell", ucv_string_new(p->pw_shell));
+
+	return rv;
+}
+
+static uc_value_t *
+uc_luci_crypt(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *phrase = uc_fn_arg(0);
+	uc_value_t *setting = uc_fn_arg(1);
+	char *hash;
+
+	if (ucv_type(phrase) != UC_STRING || ucv_type(setting) != UC_STRING)
+		return NULL;
+
+	errno = 0;
+	hash = crypt(ucv_string_get(phrase), ucv_string_get(setting));
+
+	if (hash == NULL || errno != 0)
+		return NULL;
+
+	return ucv_string_new(hash);
+}
+
+static uc_value_t *
+uc_luci_getuid(uc_vm_t *vm, size_t nargs) {
+	return ucv_int64_new(getuid());
+}
+
+static uc_value_t *
+uc_luci_getgid(uc_vm_t *vm, size_t nargs) {
+	return ucv_int64_new(getgid());
+}
+
+static uc_value_t *
+uc_luci_setuid(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *uid = uc_fn_arg(0);
+
+	if (ucv_type(uid) != UC_INTEGER)
+		return NULL;
+
+	return ucv_boolean_new(setuid(ucv_int64_get(uid)) == 0);
+}
+
+static uc_value_t *
+uc_luci_setgid(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *gid = uc_fn_arg(0);
+
+	if (ucv_type(gid) != UC_INTEGER)
+		return NULL;
+
+	return ucv_boolean_new(setgid(ucv_int64_get(gid)) == 0);
+}
+
+
+/* misc functions */
+
+static uc_value_t *
+uc_luci_kill(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *pid = uc_fn_arg(0);
+	uc_value_t *sig = uc_fn_arg(1);
+
+	if (ucv_type(pid) != UC_INTEGER || ucv_type(sig) != UC_INTEGER)
+		return NULL;
+
+	return ucv_boolean_new(kill(ucv_int64_get(pid), ucv_int64_get(sig)) == 0);
+}
+
+static uc_value_t *
+uc_luci_uname(uc_vm_t *vm, size_t nargs) {
+	struct utsname u;
+	uc_value_t *rv;
+
+	if (uname(&u) == -1)
+		return NULL;
+
+	rv = ucv_object_new(vm);
+
+	ucv_object_add(rv, "sysname", ucv_string_new(u.sysname));
+	ucv_object_add(rv, "nodename", ucv_string_new(u.nodename));
+	ucv_object_add(rv, "release", ucv_string_new(u.release));
+	ucv_object_add(rv, "version", ucv_string_new(u.version));
+	ucv_object_add(rv, "machine", ucv_string_new(u.machine));
+
+	return rv;
+}
+
+static uc_value_t *
+uc_luci_sysinfo(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *rv, *loads;
+	struct sysinfo i;
+
+	if (sysinfo(&i) == -1)
+		return NULL;
+
+	rv = ucv_object_new(vm);
+	loads = ucv_array_new_length(vm, 3);
+
+	ucv_array_push(loads, ucv_uint64_new(i.loads[0]));
+	ucv_array_push(loads, ucv_uint64_new(i.loads[1]));
+	ucv_array_push(loads, ucv_uint64_new(i.loads[2]));
+
+	ucv_object_add(rv, "uptime", ucv_int64_new(i.uptime));
+	ucv_object_add(rv, "loads", loads);
+	ucv_object_add(rv, "totalram", ucv_uint64_new(i.totalram));
+	ucv_object_add(rv, "freeram", ucv_uint64_new(i.freeram));
+	ucv_object_add(rv, "sharedram", ucv_uint64_new(i.sharedram));
+	ucv_object_add(rv, "bufferram", ucv_uint64_new(i.bufferram));
+	ucv_object_add(rv, "totalswap", ucv_uint64_new(i.totalswap));
+	ucv_object_add(rv, "freeswap", ucv_uint64_new(i.freeswap));
+	ucv_object_add(rv, "procs", ucv_uint64_new(i.procs));
+	ucv_object_add(rv, "totalhigh", ucv_uint64_new(i.totalhigh));
+	ucv_object_add(rv, "freehigh", ucv_uint64_new(i.freehigh));
+	ucv_object_add(rv, "mem_unit", ucv_uint64_new(i.mem_unit));
+
+	return rv;
+}
+
+static uc_value_t *
+uc_luci_statvfs(uc_vm_t *vm, size_t nargs) {
+	uc_value_t *path = uc_fn_arg(0), *rv;
+	struct statvfs s;
+
+	if (ucv_type(path) != UC_STRING)
+		return NULL;
+
+	if (statvfs(ucv_string_get(path), &s) == -1)
+		return NULL;
+
+	rv = ucv_object_new(vm);
+
+	ucv_object_add(rv, "bsize", ucv_uint64_new(s.f_bsize));
+	ucv_object_add(rv, "frsize", ucv_uint64_new(s.f_frsize));
+
+	ucv_object_add(rv, "blocks", ucv_uint64_new(s.f_blocks));
+	ucv_object_add(rv, "bfree", ucv_uint64_new(s.f_bfree));
+	ucv_object_add(rv, "bavail", ucv_uint64_new(s.f_bavail));
+
+	ucv_object_add(rv, "files", ucv_uint64_new(s.f_files));
+	ucv_object_add(rv, "ffree", ucv_uint64_new(s.f_ffree));
+	ucv_object_add(rv, "favail", ucv_uint64_new(s.f_favail));
+
+	ucv_object_add(rv, "fsid", ucv_uint64_new(s.f_fsid));
+	ucv_object_add(rv, "flag", ucv_uint64_new(s.f_flag));
+	ucv_object_add(rv, "namemax", ucv_uint64_new(s.f_namemax));
+
+	return rv;
+}
+
+
+static const uc_function_list_t luci_fns[] = {
+	{ "load_catalog",		uc_luci_load_catalog },
+	{ "close_catalog",		uc_luci_close_catalog },
+	{ "change_catalog",		uc_luci_change_catalog },
+	{ "get_translations",	uc_luci_get_translations },
+	{ "translate",			uc_luci_translate },
+	{ "ntranslate",			uc_luci_ntranslate },
+	{ "hash",				uc_luci_hash },
+
+	{ "getspnam",			uc_luci_getspnam },
+	{ "getpwnam",			uc_luci_getpwnam },
+	{ "crypt",				uc_luci_crypt },
+	{ "getuid",				uc_luci_getuid },
+	{ "setuid",				uc_luci_setuid },
+	{ "getgid",				uc_luci_getgid },
+	{ "setgid",				uc_luci_setgid },
+
+	{ "kill",				uc_luci_kill },
+	{ "uname",				uc_luci_uname },
+	{ "sysinfo",			uc_luci_sysinfo },
+	{ "statvfs",			uc_luci_statvfs },
+};
+
+
+void uc_module_init(uc_vm_t *vm, uc_value_t *scope)
+{
+	uc_function_list_register(scope, luci_fns);
+}

luci-base/src/lib/plural_formula.y

@@ -0,0 +1,43 @@
+%name pluralParse
+%token_type {int}
+%extra_argument {struct parse_state *s}
+
+%right T_QMARK.
+%left T_OR.
+%left T_AND.
+%left T_EQ T_NE.
+%left T_LT T_LE T_GT T_GE.
+%left T_ADD T_SUB.
+%left T_MUL T_DIV T_MOD.
+%right T_NOT.
+%nonassoc T_COLON T_N T_LPAREN T_RPAREN.
+
+%include {
+#include <assert.h>
+
+struct parse_state {
+	int num;
+	int res;
+};
+}
+
+input ::= expr(A).										{ s->res = A; }
+
+expr(A) ::= expr(B) T_QMARK expr(C) T_COLON expr(D).	{ A = B ? C : D; }
+expr(A) ::= expr(B) T_OR expr(C).						{ A = B || C; }
+expr(A) ::= expr(B) T_AND expr(C).						{ A = B && C; }
+expr(A) ::= expr(B) T_EQ expr(C).						{ A = B == C; }
+expr(A) ::= expr(B) T_NE expr(C).						{ A = B != C; }
+expr(A) ::= expr(B) T_LT expr(C).						{ A = B < C; }
+expr(A) ::= expr(B) T_LE expr(C).						{ A = B <= C; }
+expr(A) ::= expr(B) T_GT expr(C).						{ A = B > C; }
+expr(A) ::= expr(B) T_GE expr(C).						{ A = B >= C; }
+expr(A) ::= expr(B) T_ADD expr(C).						{ A = B + C; }
+expr(A) ::= expr(B) T_SUB expr(C).						{ A = B - C; }
+expr(A) ::= expr(B) T_MUL expr(C).						{ A = B * C; }
+expr(A) ::= expr(B) T_DIV expr(C).						{ A = B / C; }
+expr(A) ::= expr(B) T_MOD expr(C).						{ A = B % C; }
+expr(A) ::= T_NOT expr(B).								{ A = !B; }
+expr(A) ::= T_N.										{ A = s->num; }
+expr(A) ::= T_NUM(B).									{ A = B; }
+expr(A) ::= T_LPAREN expr(B) T_RPAREN.					{ A = B; }

luci-base/src/po2lmo.c

@@ -0,0 +1,335 @@
+/*
+ * lmo - Lua Machine Objects - PO to LMO conversion tool
+ *
+ *   Copyright (C) 2009-2012 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "lib/lmo.h"
+
+static void die(const char *msg)
+{
+	fprintf(stderr, "Error: %s\n", msg);
+	exit(1);
+}
+
+static void usage(const char *name)
+{
+	fprintf(stderr, "Usage: %s input.po output.lmo\n", name);
+	exit(1);
+}
+
+static void print(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+	int i;
+
+	if (fwrite(ptr, size, nmemb, stream) == 0)
+		die("Failed to write");
+
+	for (i = 0; i <	((4 - (size % 4)) % 4); i++)
+		if (fputc(0, stream))
+			die("Failed to write");
+}
+
+static int extract_string(const char *src, char *dest, int len)
+{
+	int pos = 0;
+	int esc = 0;
+	int off = -1;
+
+	if (*src == '#')
+		return -1;
+
+	for( pos = 0; (pos < strlen(src)) && (pos < len); pos++ )
+	{
+		if( (off == -1) && (src[pos] == '"') )
+		{
+			off = pos + 1;
+		}
+		else if( off >= 0 )
+		{
+			if( esc == 1 )
+			{
+				switch (src[pos])
+				{
+				case '"':
+				case '\\':
+					off++;
+					break;
+				}
+				dest[pos-off] = src[pos];
+				esc = 0;
+			}
+			else if( src[pos] == '\\' )
+			{
+				dest[pos-off] = src[pos];
+				esc = 1;
+			}
+			else if( src[pos] != '"' )
+			{
+				dest[pos-off] = src[pos];
+			}
+			else
+			{
+				dest[pos-off] = '\0';
+				break;
+			}
+		}
+	}
+
+	return (off > -1) ? strlen(dest) : -1;
+}
+
+static int cmp_index(const void *a, const void *b)
+{
+	uint32_t x = ((const lmo_entry_t *)a)->key_id;
+	uint32_t y = ((const lmo_entry_t *)b)->key_id;
+
+	if (x < y)
+		return -1;
+	else if (x > y)
+		return 1;
+
+	return 0;
+}
+
+static void print_uint32(uint32_t x, FILE *out)
+{
+	uint32_t y = htonl(x);
+	print(&y, sizeof(uint32_t), 1, out);
+}
+
+static void print_index(void *array, int n, FILE *out)
+{
+	lmo_entry_t *e;
+
+	qsort(array, n, sizeof(*e), cmp_index);
+
+	for (e = array; n > 0; n--, e++)
+	{
+		print_uint32(e->key_id, out);
+		print_uint32(e->val_id, out);
+		print_uint32(e->offset, out);
+		print_uint32(e->length, out);
+	}
+}
+
+enum fieldtype {
+	UNSPEC        = 0,
+	MSG_CTXT      = 1,
+	MSG_ID        = 2,
+	MSG_ID_PLURAL = 3,
+	MSG_STR       = 4
+};
+
+struct msg {
+	int plural_num;
+	char *ctxt;
+	char *id;
+	char *id_plural;
+	char *val[10];
+	size_t len;
+	char **cur;
+};
+
+static void *array = NULL;
+static int n_entries = 0;
+static size_t offset = 0;
+
+static void print_msg(struct msg *msg, FILE *out)
+{
+	char key[4096], *field, *p;
+	uint32_t key_id, val_id;
+	lmo_entry_t *entry;
+	size_t len;
+	int esc, i;
+
+	if (msg->id && msg->val[0]) {
+		for (i = 0; i <= msg->plural_num; i++) {
+			if (!msg->val[i])
+				continue;
+
+			if (msg->ctxt && msg->id_plural)
+				snprintf(key, sizeof(key), "%s\1%s\2%d", msg->ctxt, msg->id, i);
+			else if (msg->ctxt)
+				snprintf(key, sizeof(key), "%s\1%s", msg->ctxt, msg->id);
+			else if (msg->id_plural)
+				snprintf(key, sizeof(key), "%s\2%d", msg->id, i);
+			else
+				snprintf(key, sizeof(key), "%s", msg->id);
+
+			len = strlen(key);
+			key_id = sfh_hash(key, len, len);
+
+			len = strlen(msg->val[i]);
+			val_id = sfh_hash(msg->val[i], len, len);
+
+			if (key_id != val_id) {
+				n_entries++;
+				array = realloc(array, n_entries * sizeof(lmo_entry_t));
+
+				if (!array)
+					die("Out of memory");
+
+				entry = (lmo_entry_t *)array + n_entries - 1;
+				entry->key_id = key_id;
+				entry->val_id = msg->plural_num + 1;
+				entry->offset = offset;
+				entry->length = strlen(msg->val[i]);
+
+				len = entry->length + ((4 - (entry->length % 4)) % 4);
+
+				print(msg->val[i], entry->length, 1, out);
+				offset += len;
+			}
+		}
+	}
+	else if (msg->val[0]) {
+		for (field = msg->val[0], p = field, esc = 0; *p; p++) {
+			if (esc) {
+				if (*p == 'n') {
+					p[-1] = 0;
+
+					if (!strncasecmp(field, "Plural-Forms: ", 14)) {
+						field += 14;
+
+						n_entries++;
+						array = realloc(array, n_entries * sizeof(lmo_entry_t));
+
+						if (!array)
+							die("Out of memory");
+
+						entry = (lmo_entry_t *)array + n_entries - 1;
+						entry->key_id = 0;
+						entry->val_id = 0;
+						entry->offset = offset;
+						entry->length = strlen(field);
+
+						len = entry->length + ((4 - (entry->length % 4)) % 4);
+
+						print(field, entry->length, 1, out);
+						offset += len;
+						break;
+					}
+
+					field = p + 1;
+				}
+
+				esc = 0;
+			}
+			else if (*p == '\\') {
+				esc = 1;
+			}
+		}
+	}
+
+	free(msg->ctxt);
+	free(msg->id);
+	free(msg->id_plural);
+
+	for (i = 0; i < sizeof(msg->val) / sizeof(msg->val[0]); i++)
+		free(msg->val[i]);
+
+	memset(msg, 0, sizeof(*msg));
+}
+
+int main(int argc, char *argv[])
+{
+	struct msg msg = { .plural_num = -1 };
+	char line[4096], tmp[4096];
+	FILE *in, *out;
+	ssize_t len;
+	int eof;
+
+	if ((argc != 3) || ((in = fopen(argv[1], "r")) == NULL) || ((out = fopen(argv[2], "w")) == NULL))
+		usage(argv[0]);
+
+	while (1) {
+		line[0] = 0;
+		eof = !fgets(line, sizeof(line), in);
+
+		if (!strncmp(line, "msgctxt \"", 9)) {
+			if (msg.id || msg.val[0])
+				print_msg(&msg, out);
+			else
+				free(msg.ctxt);
+
+			msg.ctxt = NULL;
+			msg.cur = &msg.ctxt;
+			msg.len = 0;
+		}
+		else if (eof || !strncmp(line, "msgid \"", 7)) {
+			if (msg.id || msg.val[0])
+				print_msg(&msg, out);
+			else
+				free(msg.id);
+
+			msg.id = NULL;
+			msg.cur = &msg.id;
+			msg.len = 0;
+		}
+		else if (!strncmp(line, "msgid_plural \"", 14)) {
+			free(msg.id_plural);
+			msg.id_plural = NULL;
+			msg.cur = &msg.id_plural;
+			msg.len = 0;
+		}
+		else if (!strncmp(line, "msgstr \"", 8) || !strncmp(line, "msgstr[", 7)) {
+			if (line[6] == '[')
+				msg.plural_num = strtoul(line + 7, NULL, 10);
+			else
+				msg.plural_num = 0;
+
+			if (msg.plural_num >= 10)
+				die("Too many plural forms");
+
+			free(msg.val[msg.plural_num]);
+			msg.val[msg.plural_num] = NULL;
+			msg.cur = &msg.val[msg.plural_num];
+			msg.len = 0;
+		}
+
+		if (eof)
+			break;
+
+		if (msg.cur) {
+			len = extract_string(line, tmp, sizeof(tmp));
+
+			if (len > 0) {
+				*msg.cur = realloc(*msg.cur, msg.len + len + 1);
+
+				if (!*msg.cur)
+					die("Out of memory");
+
+				memcpy(*msg.cur + msg.len, tmp, len + 1);
+				msg.len += len;
+			}
+		}
+	}
+
+	print_index(array, n_entries, out);
+
+	if (offset > 0) {
+		print_uint32(offset, out);
+		fsync(fileno(out));
+		fclose(out);
+	}
+	else {
+		fclose(out);
+		unlink(argv[2]);
+	}
+
+	fclose(in);
+	return(0);
+}