Return to newcommand.js CVS log

Up to [LON-CAPA] / loncom / html / adm / jsMath / extensions

- jsMath 3.4e

    1: /*
    2:  *  extensions/newcommand.js
    3:  *  
    4:  *  Part of the jsMath package for mathematics on the web.
    5:  *
    6:  *  This file implements the \newcommand and \def macros.  It will be
    7:  *  loaded automatically when needed, or can be loaded by
    8:  *  
    9:  *    jsMath.Extension.Require('newcommand');
   10:  *
   11:  *  ---------------------------------------------------------------------
   12:  *
   13:  *  Copyright 2005-2006 by Davide P. Cervone
   14:  * 
   15:  *  Licensed under the Apache License, Version 2.0 (the "License");
   16:  *  you may not use this file except in compliance with the License.
   17:  *  You may obtain a copy of the License at
   18:  * 
   19:  *      http://www.apache.org/licenses/LICENSE-2.0
   20:  * 
   21:  *  Unless required by applicable law or agreed to in writing, software
   22:  *  distributed under the License is distributed on an "AS IS" BASIS,
   23:  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   24:  *  See the License for the specific language governing permissions and
   25:  *  limitations under the License.
   26:  */
   27: 
   28: /********************************************************************/
   29: 
   30: jsMath.Package(jsMath.Parser,{
   31:   
   32:   macros: {
   33:     newcommand: 'NewCommand',
   34:     newenvironment: 'NewEnvironment',
   35:     def: 'MacroDef'
   36:   },
   37:   
   38:   /*
   39:    *  Implement \newcommand{\name}[n]{...}
   40:    */
   41:   NewCommand: function (name) {
   42:     var cs = this.trimSpaces(this.GetArgument(this.cmd+name)); if (this.error) return;
   43:     var n = this.trimSpaces(this.GetBrackets(this.cmd+name)); if (this.error) return;
   44:     var def = this.GetArgument(this.cmd+name); if (this.error) return;
   45:     if (n == '') {n = null}
   46:     if (cs.charAt(0) == this.cmd) {cs = cs.substr(1)}
   47:     if (!cs.match(/^(.|[a-z]+)$/)) {this.Error("Illegal control sequence name for "+this.cmd+name); return}
   48:     if (n != null && !n.match(/^[0-9]+$/)) {this.Error("Illegal number of parameters specified in "+this.cmd+name); return}
   49:     jsMath.Parser.prototype.macros[cs] = ['Macro',def,n];
   50:   },
   51:   
   52:   /*
   53:    *  Implement \newenvironment{name}[n]{begincmd}{endcmd}
   54:    */
   55:   NewEnvironment: function (name) {
   56:     var env = this.trimSpaces(this.GetArgument(this.cmd+name)); if (this.error) return;
   57:     var n = this.trimSpaces(this.GetBrackets(this.cmd+name)); if (this.error) return;
   58:     var bdef = this.GetArgument(this.cmd+name); if (this.error) return;
   59:     var edef = this.GetArgument(this.cmd+name); if (this.error) return;
   60:     if (n == '') {n = null}
   61:     if (n != null && !n.match(/^[0-9]+$/)) {this.Error("Illegal number of parameters specified in "+this.cmd+name); return}
   62:     jsMath.Parser.prototype.environments[env] = ['Environment',bdef,edef,n];
   63:   },
   64:   
   65:   /*
   66:    *  Implement \def command
   67:    */
   68:   MacroDef: function (name) {
   69:     var cs = this.GetCSname(this.cmd+name); if (this.error) return;
   70:     var params = this.GetTemplate(this.cmd+name); if (this.error) return;
   71:     var def = this.GetArgument(this.cmd+name); if (this.error) return;
   72:     if (typeof(params) == 'number') {
   73:       jsMath.Parser.prototype.macros[cs] = ['Macro',def,params];
   74:     } else {
   75:       jsMath.Parser.prototype.macros[cs] = ['MacroWithTemplate',def,params[0],params[1]];
   76:     }
   77:   },
   78: 
   79:   /*
   80:    *  Get a CS name or give an error
   81:    */
   82:   GetCSname: function (cmd) {
   83:     var c = this.GetNext();
   84:     if (c != this.cmd) {this.Error(cmd+" must be followed by a control sequence"); return null}
   85:     var cs = this.trimSpaces(this.GetArgument(cmd)); if (this.error) {return null};
   86:     return cs.substr(1);
   87:   },
   88:   
   89:   /*
   90:    *  Get a \def parameter template
   91:    */
   92:   GetTemplate: function (cmd) {
   93:     var c; var params = []; var n = 0;
   94:     c = this.GetNext(); var i = this.i;
   95:     while (this.i < this.string.length) {
   96:       c = this.GetNext();
   97:       if (c == '#') {
   98:         if (i != this.i) {params[n] = this.string.substr(i,this.i-i)}
   99:         c = this.string.charAt(++this.i);
  100:         if (!c.match(/[1-9]/)) {this.Error("Illegal use of # in "+cmd); return null}
  101:         if (1*c != ++n) {this.Error("Parameters must be numbered sequentially"); return null}
  102:         i = this.i+1;
  103:       } else if (c == '{') {
  104:         if (i != this.i) {params[n] = this.string.substr(i,this.i-i)}
  105:         if (params.length > 0) {return [n,params]} else {return n}
  106:       }
  107:       this.i++;
  108:     }
  109:     this.Error("Missing replacement string for definition of "+cmd);
  110:     return null;
  111:   },
  112:   
  113:   /*
  114:    *  Process a macro with a parameter template
  115:    */
  116:   MacroWithTemplate: function (name,data) {
  117:     var text = data[0];
  118:     var n = data[1]; var params = data[2];
  119:     if (n) {
  120:       var args = []; var c = this.GetNext();
  121:       if (params[0] && !this.MatchParam(params[0]))
  122:         {this.Error("Use of "+this.cmd+name+" doesn't match its definition"); return}
  123:       for (var i = 0; i < n; i++) {
  124:         args[args.length] = this.GetParameter(this.cmd+name,params[i+1]);
  125:         if (this.error) return;
  126:       }
  127:       text = this.SubstituteArgs(args,text);
  128:     }
  129:     this.string = this.AddArgs(text,this.string.slice(this.i));
  130:     this.i = 0;
  131:   },
  132:   
  133:   /*
  134:    *  Process a user-defined environment
  135:    */
  136:   Environment: function (name,data) {
  137:     var bdef = data[0]; var edef = data[1]; var n = data[2];
  138:     if (n) {
  139:       var args = [];
  140:       for (var i = 0; i < n; i++) {
  141:         args[args.length] = this.GetArgument(this.cmd+"begin{"+name+"}"); if (this.error) return;
  142:       }
  143:       bdef = this.SubstituteArgs(args,bdef);
  144:     }
  145:     var text = this.GetEnd(name); if (this.error) return;
  146:     text = this.AddArgs(this.AddArgs(bdef,text),edef);
  147:     this.string = this.AddArgs(text,this.string.slice(this.i));
  148:     this.i = 0;
  149:   },
  150: 
  151:   /*
  152:    *  Find a single parameter delimited by a trailing template
  153:    */
  154:   GetParameter: function (name,param) {
  155:     if (param == null) {return this.GetArgument(name)}
  156:     var i = this.i; var j = 0; var hasBraces = 0;
  157:     while (this.i < this.string.length) {
  158:       if (this.string.charAt(this.i) == '{') {
  159:         if (this.i == i) {hasBraces = 1}
  160:         this.GetArgument(name); j = this.i - i;
  161:       } else if (this.MatchParam(param)) {
  162:         if (hasBraces) {i++; j -= 2}
  163:         return this.string.substr(i,j);
  164:       } else {
  165:         this.i++; j++; hasBraces = 0;
  166:       }
  167:     }
  168:     this.Error("Runaway argument for "+name+"?");
  169:     return null;
  170:   },
  171: 
  172:   /*
  173:    *  Check if a template is at the current location.
  174:    *  (The match must be exact, with no spacing differences.  TeX is
  175:    *   a little more forgiving about spaces after macro names)
  176:    */
  177:   MatchParam: function (param) {
  178:     if (this.string.substr(this.i,param.length) != param) {return 0}
  179:     this.i += param.length;
  180:     return 1;
  181:   }
  182:   
  183: });
  184: 
  185: /*
  186:  *  Define a jsMath.Environment() command similar to the
  187:  *  jsMath.Macro() command.
  188:  *  
  189:  *  Usage:  jsMath.Environment(name,begin,end[,n])
  190:  *  
  191:  *  where "name" is the name of the environment, "begin" is the
  192:  *  text that replaces the \begin{name} and "end" is the text that
  193:  *  replaces the \end{name}.  If "n" is provided, it is the number
  194:  *  of parameters that the \begin{name} accepts, and these are
  195:  *  used to replace #1, #2, etc within the "begin" text.
  196:  */
  197: 
  198: jsMath.Add(jsMath,{
  199:   Environment: function (name) {
  200:     var environments = jsMath.Parser.prototype.environments;
  201:     environments[name] = ['Environment'];
  202:     for (var i = 1; i < arguments.length; i++) 
  203:       {environments[name][environments[name].length] = arguments[i]}
  204:   }
  205: });