Return to capaMapExpr.c CVS log

Up to [LON-CAPA] / capa / capa51 / pProj

Annotation of capa/capa51/pProj/capaMapExpr.c, revision 1.4

1.2       albertel    1: /* definition of the /MAP and /RMAP commands
                      2:    Copyright (C) 1992-2000 Michigan State University
                      3: 
                      4:    The CAPA system is free software; you can redistribute it and/or
1.4     ! albertel    5:    modify it under the terms of the GNU General Public License as
1.2       albertel    6:    published by the Free Software Foundation; either version 2 of the
                      7:    License, or (at your option) any later version.
                      8: 
                      9:    The CAPA system is distributed in the hope that it will be useful,
                     10:    but WITHOUT ANY WARRANTY; without even the implied warranty of
                     11:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1.4     ! albertel   12:    General Public License for more details.
1.2       albertel   13: 
1.4     ! albertel   14:    You should have received a copy of the GNU General Public
1.2       albertel   15:    License along with the CAPA system; see the file COPYING.  If not,
                     16:    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
1.3       albertel   17:    Boston, MA 02111-1307, USA.
                     18: 
                     19:    As a special exception, you have permission to link this program
                     20:    with the TtH/TtM library and distribute executables, as long as you
                     21:    follow the requirements of the GNU GPL in regard to all of the
                     22:    software in the executable aside from TtH/TtM.
                     23: */
1.2       albertel   24: 
1.1       albertel   25: /* ========================================================================== */
                     26: /*            capaMapExpr.c    created by Isaac Tsai                       */
                     27: /*                                                                         */
                     28: /*  this is the main code to handle /MAP() function call in capa */
                     29: #include <stdio.h>
                     30: #include <string.h>
                     31: #include <math.h>
                     32: 
                     33: #include "capaParser.h"
                     34: #include "capaToken.h"
                     35: #include "ranlib.h"
                     36: 
                     37: 
                     38:             
                     39: /* |>|===============================================================|<| */
                     40: int
                     41: do_map(seed, varp, argp, argc, dir) 
                     42: char *seed; ArgNode_t *varp; ArgNode_t *argp; int argc; int dir;
                     43: {
                     44:   long        orig_gen, current_gen, seed1, seed2;
                     45:   long       *idx_array, *ridx_array;
                     46:   int         idx, val;
                     47:   Symbol      val_array[ONE_K];
                     48:   ArgNode_t  *tmpArgp;
                     49:   
                     50: 
                     51:   for(idx=0,tmpArgp=argp;idx<argc;idx++) {
                     52:     switch( FIRST_ARGTYPE(tmpArgp) ) {
                     53:     case I_VAR:
                     54:     case I_CONSTANT:
                     55:          (val_array[idx]).s_type = I_VAR;
                     56:          (val_array[idx]).s_int = FIRST_ARGINT(tmpArgp); break;
                     57:     case R_VAR:
                     58:     case R_CONSTANT:
                     59:          (val_array[idx]).s_type = R_VAR;
                     60:          (val_array[idx]).s_real = FIRST_ARGREAL(tmpArgp); break;
                     61:     case S_VAR:
                     62:     case S_CONSTANT:
                     63:          (val_array[idx]).s_type = S_VAR;
                     64:          (val_array[idx]).s_str = strsave(FIRST_ARGSTR(tmpArgp)); break;
                     65:     default:
                     66:          return -1;
                     67: 	 break;
                     68:     }
                     69:     tmpArgp =  (tmpArgp->a_next);
                     70:   }
                     71:   idx_array = (long *)capa_malloc(sizeof(long), argc);
                     72:   for(idx=0;idx<argc;idx++) idx_array[idx] = idx;
                     73:   gscgn(GET_GENERATOR, &orig_gen);
                     74:   current_gen = PERMUTATION_G;
                     75:   gscgn(SET_GENERATOR, &current_gen);
                     76:   phrtsd(seed, &seed1, &seed2);
                     77:   setsd(seed1, seed2);
                     78:   genprm(idx_array, (long)argc);
                     79:   if(dir == REVERSE_MAP) {
                     80:     ridx_array = (long *)capa_malloc(sizeof(long), argc);
                     81:     for(idx=0;idx<argc;idx++) {
                     82:       ridx_array[ idx_array[idx] ] = idx;
                     83:     }
                     84:     for(idx=0;idx<argc;idx++) {
                     85:       idx_array[idx] = ridx_array[idx];
                     86:     }
                     87:     capa_mfree((char *)ridx_array);
                     88:   }
                     89:   for(idx=0,tmpArgp=varp;idx<argc;idx++) {
                     90:     val = idx_array[idx];
                     91:     switch( FIRST_ARGTYPE(tmpArgp) ) {
                     92:       case IDENTIFIER:
                     93:       case I_VAR: case I_CONSTANT:
                     94:       case R_VAR: case R_CONSTANT: break;
                     95:       case S_VAR: case S_CONSTANT: capa_mfree((char *)FIRST_ARGSTR(tmpArgp)); break;
                     96:     }
                     97:     FIRST_ARGTYPE(tmpArgp) = (val_array[val]).s_type;
                     98:     
                     99:     switch( val_array[val].s_type ) {
                    100:      case I_VAR: FIRST_ARGINT(tmpArgp) =  (val_array[val]).s_int;   break;
                    101:      case R_VAR: FIRST_ARGREAL(tmpArgp) = (val_array[val]).s_real;  break;
                    102:      case S_VAR: FIRST_ARGSTR(tmpArgp) =  (val_array[val]).s_str;   break;
                    103:     }
                    104:     tmpArgp = tmpArgp->a_next;
                    105:   }
                    106:   gscgn(SET_GENERATOR, &orig_gen);
                    107:   capa_mfree((char *)idx_array);
                    108:   return (0);
                    109: }
                    110: 
                    111: