Gmsh.tab.cpp

    break;}
case 270:
#line 2893 "Gmsh.y"
{ yyval.d = log10(yyvsp[-1].d);    ;
    break;}
case 271:
#line 2894 "Gmsh.y"
{ yyval.d = sqrt(yyvsp[-1].d);     ;
    break;}
case 272:
#line 2895 "Gmsh.y"
{ yyval.d = sin(yyvsp[-1].d);      ;
    break;}
case 273:
#line 2896 "Gmsh.y"
{ yyval.d = asin(yyvsp[-1].d);     ;
    break;}
case 274:
#line 2897 "Gmsh.y"
{ yyval.d = cos(yyvsp[-1].d);      ;
    break;}
case 275:
#line 2898 "Gmsh.y"
{ yyval.d = acos(yyvsp[-1].d);     ;
    break;}
case 276:
#line 2899 "Gmsh.y"
{ yyval.d = tan(yyvsp[-1].d);      ;
    break;}
case 277:
#line 2900 "Gmsh.y"
{ yyval.d = atan(yyvsp[-1].d);     ;
    break;}
case 278:
#line 2901 "Gmsh.y"
{ yyval.d = atan2(yyvsp[-3].d, yyvsp[-1].d);;
    break;}
case 279:
#line 2902 "Gmsh.y"
{ yyval.d = sinh(yyvsp[-1].d);     ;
    break;}
case 280:
#line 2903 "Gmsh.y"
{ yyval.d = cosh(yyvsp[-1].d);     ;
    break;}
case 281:
#line 2904 "Gmsh.y"
{ yyval.d = tanh(yyvsp[-1].d);     ;
    break;}
case 282:
#line 2905 "Gmsh.y"
{ yyval.d = fabs(yyvsp[-1].d);     ;
    break;}
case 283:
#line 2906 "Gmsh.y"
{ yyval.d = floor(yyvsp[-1].d);    ;
    break;}
case 284:
#line 2907 "Gmsh.y"
{ yyval.d = ceil(yyvsp[-1].d);     ;
    break;}
case 285:
#line 2908 "Gmsh.y"
{ yyval.d = fmod(yyvsp[-3].d, yyvsp[-1].d); ;
    break;}
case 286:
#line 2909 "Gmsh.y"
{ yyval.d = fmod(yyvsp[-3].d, yyvsp[-1].d); ;
    break;}
case 287:
#line 2910 "Gmsh.y"
{ yyval.d = sqrt(yyvsp[-3].d*yyvsp[-3].d+yyvsp[-1].d*yyvsp[-1].d); ;
    break;}
case 288:
#line 2911 "Gmsh.y"
{ yyval.d = yyvsp[-1].d*(double)rand()/(double)RAND_MAX; ;
    break;}
case 289:
#line 2920 "Gmsh.y"
{ yyval.d = yyvsp[0].d; ;
    break;}
case 290:
#line 2921 "Gmsh.y"
{ yyval.d = 3.141592653589793; ;
    break;}
case 291:
#line 2922 "Gmsh.y"
{ yyval.d = ParUtil::Instance()->rank(); ;
    break;}
case 292:
#line 2923 "Gmsh.y"
{ yyval.d = ParUtil::Instance()->size(); ;
    break;}
case 293:
#line 2924 "Gmsh.y"
{ yyval.d = Get_GmshMajorVersion(); ;
    break;}
case 294:
#line 2925 "Gmsh.y"
{ yyval.d = Get_GmshMinorVersion(); ;
    break;}
case 295:
#line 2926 "Gmsh.y"
{ yyval.d = Get_GmshPatchVersion(); ;
    break;}
case 296:
#line 2931 "Gmsh.y"
{
      Symbol TheSymbol;
      TheSymbol.Name = yyvsp[0].c;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", yyvsp[0].c);
	yyval.d = 0.;
      }
      else
	yyval.d = *(double*)List_Pointer_Fast(pSymbol->val, 0);
      Free(yyvsp[0].c);
    ;
    break;}
case 297:
#line 2947 "Gmsh.y"
{
      char tmpstring[1024];
      sprintf(tmpstring, "%s_%d", yyvsp[-4].c, (int)yyvsp[-1].d) ;
      Symbol TheSymbol;
      TheSymbol.Name = tmpstring;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", tmpstring);
	yyval.d = 0.;
      }
      else
	yyval.d = *(double*)List_Pointer_Fast(pSymbol->val, 0);
      Free(yyvsp[-4].c);
    ;
    break;}
case 298:
#line 2962 "Gmsh.y"
{
      Symbol TheSymbol;
      TheSymbol.Name = yyvsp[-3].c;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", yyvsp[-3].c);
	yyval.d = 0.;
      }
      else{
	double *pd;
	if((pd = (double*)List_Pointer_Test(pSymbol->val, (int)yyvsp[-1].d)))
	  yyval.d = *pd;
	else{
	  yymsg(GERROR, "Uninitialized variable '%s[%d]'", yyvsp[-3].c, (int)yyvsp[-1].d);
	  yyval.d = 0.;
	}
      }
      Free(yyvsp[-3].c);
    ;
    break;}
case 299:
#line 2982 "Gmsh.y"
{
      Symbol TheSymbol;
      TheSymbol.Name = yyvsp[-2].c;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", yyvsp[-2].c);
	yyval.d = 0.;
      }
      else{
	yyval.d = List_Nbr(pSymbol->val);
      }
      Free(yyvsp[-2].c);
    ;
    break;}
case 300:
#line 2996 "Gmsh.y"
{
      Symbol TheSymbol;
      TheSymbol.Name = yyvsp[-1].c;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", yyvsp[-1].c);
	yyval.d = 0.;
      }
      else
	yyval.d = (*(double*)List_Pointer_Fast(pSymbol->val, 0) += yyvsp[0].i);
      Free(yyvsp[-1].c);
    ;
    break;}
case 301:
#line 3009 "Gmsh.y"
{
      Symbol TheSymbol;
      TheSymbol.Name = yyvsp[-4].c;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", yyvsp[-4].c);
	yyval.d = 0.;
      }
      else{
	double *pd;
	if((pd = (double*)List_Pointer_Test(pSymbol->val, (int)yyvsp[-2].d)))
	  yyval.d = (*pd += yyvsp[0].i);
	else{
	  yymsg(GERROR, "Uninitialized variable '%s[%d]'", yyvsp[-4].c, (int)yyvsp[-2].d);
	  yyval.d = 0.;
	}
      }
      Free(yyvsp[-4].c);
    ;
    break;}
case 302:
#line 3032 "Gmsh.y"
{
      double (*pNumOpt)(int num, int action, double value);
      StringXNumber *pNumCat;
      if(!(pNumCat = Get_NumberOptionCategory(yyvsp[-2].c))){
	yymsg(GERROR, "Unknown numeric option class '%s'", yyvsp[-2].c);
	yyval.d = 0.;
      }
      else{
	if(!(pNumOpt =  (double (*) (int, int, double))Get_NumberOption(yyvsp[0].c, pNumCat))){
	  yymsg(GERROR, "Unknown numeric option '%s.%s'", yyvsp[-2].c, yyvsp[0].c);
	  yyval.d = 0.;
	}
	else
	  yyval.d = pNumOpt(0, GMSH_GET, 0);
      }
      Free(yyvsp[-2].c); Free(yyvsp[0].c);
    ;
    break;}
case 303:
#line 3050 "Gmsh.y"
{
      double (*pNumOpt)(int num, int action, double value);
      StringXNumber *pNumCat;
      if(!(pNumCat = Get_NumberOptionCategory(yyvsp[-5].c))){
	yymsg(GERROR, "Unknown numeric option class '%s'", yyvsp[-5].c);
	yyval.d = 0.;
      }
      else{
	if(!(pNumOpt =  (double (*) (int, int, double))Get_NumberOption(yyvsp[0].c, pNumCat))){
	  yymsg(GERROR, "Unknown numeric option '%s[%d].%s'", yyvsp[-5].c, (int)yyvsp[-3].d, yyvsp[0].c);
	  yyval.d = 0.;
	}
	else
	  yyval.d = pNumOpt((int)yyvsp[-3].d, GMSH_GET, 0);
      }
      Free(yyvsp[-5].c); Free(yyvsp[0].c);
    ;
    break;}
case 304:
#line 3068 "Gmsh.y"
{
      double (*pNumOpt)(int num, int action, double value);
      StringXNumber *pNumCat;
      if(!(pNumCat = Get_NumberOptionCategory(yyvsp[-3].c))){
	yymsg(GERROR, "Unknown numeric option class '%s'", yyvsp[-3].c);
	yyval.d = 0.;
      }
      else{
	if(!(pNumOpt =  (double (*) (int, int, double))Get_NumberOption(yyvsp[-1].c, pNumCat))){
	  yymsg(GERROR, "Unknown numeric option '%s.%s'", yyvsp[-3].c, yyvsp[-1].c);
	  yyval.d = 0.;
	}
	else
	  yyval.d = pNumOpt(0, GMSH_SET|GMSH_GUI, pNumOpt(0, GMSH_GET, 0)+yyvsp[0].i);
      }
      Free(yyvsp[-3].c); Free(yyvsp[-1].c);
    ;
    break;}
case 305:
#line 3086 "Gmsh.y"
{
      double (*pNumOpt)(int num, int action, double value);
      StringXNumber *pNumCat;
      if(!(pNumCat = Get_NumberOptionCategory(yyvsp[-6].c))){
	yymsg(GERROR, "Unknown numeric option class '%s'", yyvsp[-6].c);
	yyval.d = 0.;
      }
      else{
	if(!(pNumOpt =  (double (*) (int, int, double))Get_NumberOption(yyvsp[-1].c, pNumCat))){
	  yymsg(GERROR, "Unknown numeric option '%s[%d].%s'", yyvsp[-6].c, (int)yyvsp[-4].d, yyvsp[-1].c);
	  yyval.d = 0.;
	}
	else
	  yyval.d = pNumOpt((int)yyvsp[-4].d, GMSH_SET|GMSH_GUI, pNumOpt((int)yyvsp[-4].d, GMSH_GET, 0)+yyvsp[0].i);
      }
      Free(yyvsp[-6].c); Free(yyvsp[-1].c);
    ;
    break;}
case 306:
#line 3104 "Gmsh.y"
{ 
      yyval.d = GetValue(yyvsp[-3].c, yyvsp[-1].d);
      Free(yyvsp[-3].c);
    ;
    break;}
case 307:
#line 3112 "Gmsh.y"
{
      memcpy(yyval.v, yyvsp[0].v, 5*sizeof(double));
    ;
    break;}
case 308:
#line 3116 "Gmsh.y"
{
      for(int i = 0; i < 5; i++) yyval.v[i] = -yyvsp[0].v[i];
    ;
    break;}
case 309:
#line 3120 "Gmsh.y"
{ 
      for(int i = 0; i < 5; i++) yyval.v[i] = yyvsp[0].v[i];
    ;
    break;}
case 310:
#line 3124 "Gmsh.y"
{ 
      for(int i = 0; i < 5; i++) yyval.v[i] = yyvsp[-2].v[i] - yyvsp[0].v[i];
    ;
    break;}
case 311:
#line 3128 "Gmsh.y"
{
      for(int i = 0; i < 5; i++) yyval.v[i] = yyvsp[-2].v[i] + yyvsp[0].v[i];
    ;
    break;}
case 312:
#line 3135 "Gmsh.y"
{ 
      yyval.v[0] = yyvsp[-9].d;  yyval.v[1] = yyvsp[-7].d;  yyval.v[2] = yyvsp[-5].d;  yyval.v[3] = yyvsp[-3].d; yyval.v[4] = yyvsp[-1].d;
    ;
    break;}
case 313:
#line 3139 "Gmsh.y"
{ 
      yyval.v[0] = yyvsp[-7].d;  yyval.v[1] = yyvsp[-5].d;  yyval.v[2] = yyvsp[-3].d;  yyval.v[3] = yyvsp[-1].d; yyval.v[4] = 1.0;
    ;
    break;}
case 314:
#line 3143 "Gmsh.y"
{
      yyval.v[0] = yyvsp[-5].d;  yyval.v[1] = yyvsp[-3].d;  yyval.v[2] = yyvsp[-1].d;  yyval.v[3] = 0.0; yyval.v[4] = 1.0;
    ;
    break;}
case 315:
#line 3147 "Gmsh.y"
{
      yyval.v[0] = yyvsp[-5].d;  yyval.v[1] = yyvsp[-3].d;  yyval.v[2] = yyvsp[-1].d;  yyval.v[3] = 0.0; yyval.v[4] = 1.0;
    ;
    break;}
case 316:
#line 3154 "Gmsh.y"
{
      yyval.l = List_Create(2, 1, sizeof(List_T*));
      List_Add(yyval.l, &(yyvsp[0].l));
    ;
    break;}
case 317:
#line 3159 "Gmsh.y"
{
      List_Add(yyval.l, &(yyvsp[0].l));
    ;
    break;}
case 318:
#line 3167 "Gmsh.y"
{
      yyval.l = List_Create(2, 1, sizeof(double));
      List_Add(yyval.l, &(yyvsp[0].d));
    ;
    break;}
case 319:
#line 3172 "Gmsh.y"
{
      yyval.l = yyvsp[0].l;
    ;
    break;}
case 320:
#line 3176 "Gmsh.y"
{
      // creates an empty list
      yyval.l = List_Create(2, 1, sizeof(double));
    ;
    break;}
case 321:
#line 3181 "Gmsh.y"
{
      yyval.l = yyvsp[-1].l;
    ;
    break;}
case 322:
#line 3185 "Gmsh.y"
{
      yyval.l = yyvsp[-1].l;
      for(int i = 0; i < List_Nbr(yyval.l); i++){
	double *pd = (double*)List_Pointer(yyval.l, i);
	(*pd) = - (*pd);
      }
    ;
    break;}
case 323:
#line 3193 "Gmsh.y"
{
      yyval.l = yyvsp[-1].l;
      for(int i = 0; i < List_Nbr(yyval.l); i++){
	double *pd = (double*)List_Pointer(yyval.l, i);
	(*pd) *= yyvsp[-4].d;
      }
    ;
    break;}
case 324:
#line 3204 "Gmsh.y"
{
      yyval.l = yyvsp[0].l;
      for(int i = 0; i < List_Nbr(yyval.l); i++){
	double *pd = (double*)List_Pointer(yyval.l, i);
	(*pd) = - (*pd);
      }
    ;
    break;}
case 325:
#line 3212 "Gmsh.y"
{
      yyval.l = yyvsp[0].l;
      for(int i = 0; i < List_Nbr(yyval.l); i++){
	double *pd = (double*)List_Pointer(yyval.l, i);
	(*pd) *= yyvsp[-2].d;
      }
    ;
    break;}
case 326:
#line 3220 "Gmsh.y"
{ 
      yyval.l = List_Create(2, 1, sizeof(double)); 
      for(double d = yyvsp[-2].d; (yyvsp[-2].d < yyvsp[0].d) ? (d <= yyvsp[0].d) : (d >= yyvsp[0].d); (yyvsp[-2].d < yyvsp[0].d) ? (d += 1.) : (d -= 1.)) 
	List_Add(yyval.l, &d);
    ;
    break;}
case 327:
#line 3226 "Gmsh.y"
{
      yyval.l = List_Create(2, 1, sizeof(double)); 
      if(!yyvsp[0].d || (yyvsp[-4].d < yyvsp[-2].d && yyvsp[0].d < 0) || (yyvsp[-4].d > yyvsp[-2].d && yyvsp[0].d > 0)){
        yymsg(GERROR, "Wrong increment in '%g:%g:%g'", yyvsp[-4].d, yyvsp[-2].d, yyvsp[0].d);
	List_Add(yyval.l, &(yyvsp[-4].d));
      }
      else
	for(double d = yyvsp[-4].d; (yyvsp[0].d > 0) ? (d <= yyvsp[-2].d) : (d >= yyvsp[-2].d); d += yyvsp[0].d)
	  List_Add(yyval.l, &d);
   ;
    break;}
case 328:
#line 3237 "Gmsh.y"
{
      // Returns the coordinates of a point and fills a list with it.
      // This allows to ensure e.g. that relative point positions are
      // always conserved
      Vertex *v = FindPoint((int)yyvsp[-1].d);
      yyval.l = List_Create(3, 1, sizeof(double));      
      if(!v) {
	yymsg(GERROR, "Unknown point '%d'", (int) yyvsp[-1].d);
	double d = 0.0;
	List_Add(yyval.l, &d);
	List_Add(yyval.l, &d);
	List_Add(yyval.l, &d);
      }
      else{
	List_Add(yyval.l, &v->Pos.X);
	List_Add(yyval.l, &v->Pos.Y);
	List_Add(yyval.l, &v->Pos.Z);
      }
    ;
    break;}
case 329:
#line 3257 "Gmsh.y"
{
      yyval.l = List_Create(List_Nbr(yyvsp[0].l), 1, sizeof(double));
      for(int i = 0; i < List_Nbr(yyvsp[0].l); i++){
	Shape *s = (Shape*) List_Pointer(yyvsp[0].l, i);
	double d = s->Num;
	List_Add(yyval.l, &d);
      }
      List_Delete(yyvsp[0].l);
    ;
    break;}
case 330:
#line 3267 "Gmsh.y"
{
      yyval.l = List_Create(List_Nbr(yyvsp[0].l), 1, sizeof(double));
      for(int i = 0; i < List_Nbr(yyvsp[0].l); i++){
	Shape *s = (Shape*) List_Pointer(yyvsp[0].l, i);
	double d = s->Num;
	List_Add(yyval.l, &d);
      }
      List_Delete(yyvsp[0].l);
    ;
    break;}
case 331:
#line 3277 "Gmsh.y"
{
      yyval.l = List_Create(List_Nbr(yyvsp[0].l), 1, sizeof(double));
      for(int i = 0; i < List_Nbr(yyvsp[0].l); i++){
	Shape *s = (Shape*) List_Pointer(yyvsp[0].l, i);
	double d = s->Num;
	List_Add(yyval.l, &d);
      }
      List_Delete(yyvsp[0].l);
    ;
    break;}
case 332:
#line 3287 "Gmsh.y"
{
      yyval.l = List_Create(2, 1, sizeof(double));
      Symbol TheSymbol;
      TheSymbol.Name = yyvsp[-2].c;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", yyvsp[-2].c);
	double d = 0.0;
	List_Add(yyval.l, &d);
      }
      else{
	for(int i = 0; i < List_Nbr(pSymbol->val); i++)
	  List_Add(yyval.l, (double*)List_Pointer_Fast(pSymbol->val, i));
      }
      Free(yyvsp[-2].c);
    ;
    break;}
case 333:
#line 3304 "Gmsh.y"
{
      yyval.l = List_Create(2, 1, sizeof(double));
      Symbol TheSymbol;
      TheSymbol.Name = yyvsp[-5].c;
      Symbol *pSymbol;
      if(!(pSymbol = (Symbol*)Tree_PQuery(Symbol_T, &TheSymbol))) {
	yymsg(GERROR, "Unknown variable '%s'", yyvsp[-5].c);
	double d = 0.0;
	List_Add(yyval.l, &d);
      }
      else{
	for(int i = 0; i < List_Nbr(yyvsp[-2].l); i++){
	  int j = (int)(*(double*)List_Pointer_Fast(yyvsp[-2].l, i));
	  double *pd;
	  if((pd = (double*)List_Pointer_Test(pSymbol->val, j)))
	    List_Add(yyval.l, pd);
	  else
	    yymsg(GERROR, "Uninitialized variable '%s[%d]'", yyvsp[-5].c, j);	  
	}
      }
      Free(yyvsp[-5].c);
      List_Delete(yyvsp[-2].l);
    ;
    break;}
case 334:
#line 3331 "Gmsh.y"
{
      yyval.l = List_Create(2, 1, sizeof(double));
      List_Add(yyval.l, &(yyvsp[0].d));
    ;
    break;}
case 335:
#line 3336 "Gmsh.y"
{
      yyval.l = yyvsp[0].l;
    ;
    break;}
case 336:
#line 3340 "Gmsh.y"
{
      List_Add(yyval.l, &(yyvsp[0].d));
    ;
    break;}
case 337:
#line 3344 "Gmsh.y"
{
      for(int i = 0; i < List_Nbr(yyvsp[0].l); i++){
	double d;
	List_Read(yyvsp[0].l, i, &d);
	List_Add(yyval.l, &d);
      }
      List_Delete(yyvsp[0].l);
    ;
    break;}
case 338:
#line 3357 "Gmsh.y"
{
      yyval.u = CTX.PACK_COLOR((int)yyvsp[-7].d, (int)yyvsp[-5].d, (int)yyvsp[-3].d, (int)yyvsp[-1].d);
    ;
    break;}
case 339:
#line 3361 "Gmsh.y"
{
      yyval.u = CTX.PACK_COLOR((int)yyvsp[-5].d, (int)yyvsp[-3].d, (int)yyvsp[-1].d, 255);
    ;
    break;}
case 340:
#line 3373 "Gmsh.y"
{
      int flag;
      yyval.u = Get_ColorForString(ColorString, -1, yyvsp[0].c, &flag);
      if(flag) yymsg(GERROR, "Unknown color '%s'", yyvsp[0].c);
      Free(yyvsp[0].c);
    ;
    break;}
case 341:
#line 3380 "Gmsh.y"
{
      unsigned int (*pColOpt)(int num, int action, unsigned int value);
      StringXColor *pColCat;
      if(!(pColCat = Get_ColorOptionCategory(yyvsp[-4].c))){
	yymsg(GERROR, "Unknown color option class '%s'", yyvsp[-4].c);
	yyval.u = 0;
      }
      else{
	if(!(pColOpt =  (unsigned int (*) (int, int, unsigned int))Get_ColorOption(yyvsp[0].c, pColCat))){
	  yymsg(GERROR, "Unknown color option '%s.Color.%s'", yyvsp[-4].c, yyvsp[0].c);
	  yyval.u = 0;
	}
	else{
	  yyval.u = pColOpt(0, GMSH_GET, 0);
	}
      }
      Free(yyvsp[-4].c); Free(yyvsp[0].c);
    ;
    break;}
case 342:
#line 3402 "Gmsh.y"
{
      yyval.l = yyvsp[-1].l;
    ;
    break;}
case 343:
#line 3406 "Gmsh.y"
{
      yyval.l = List_Create(256, 10, sizeof(unsigned int));
      GmshColorTable *ct = Get_ColorTable((int)yyvsp[-3].d);
      if(!ct)
	yymsg(GERROR, "View[%d] does not exist", (int)yyvsp[-3].d);
      else{
	for(int i = 0; i < ct->size; i++) 
	  List_Add(yyval.l, &ct->table[i]);
      }
      Free(yyvsp[-5].c);
    ;
    break;}
case 344:
#line 3421 "Gmsh.y"
{
      yyval.l = List_Create(256, 10, sizeof(unsigned int));
      List_Add(yyval.l, &(yyvsp[0].u));
    ;
    break;}
case 345:
#line 3426 "Gmsh.y"
{
      List_Add(yyval.l, &(yyvsp[0].u));
    ;
    break;}
case 346:
#line 3433 "Gmsh.y"
{
      yyval.c = yyvsp[0].c;
    ;
    break;}
case 347:
#line 3437 "Gmsh.y"
{
      Msg(WARNING, "Named string expressions not implemented yet");
    ;
    break;}
case 348:
#line 3444 "Gmsh.y"
{
      yyval.c = yyvsp[0].c;
    ;
    break;}
case 349:
#line 3448 "Gmsh.y"
{
      yyval.c = (char *)Malloc(32*sizeof(char));
      time_t now;
      time(&now);
      strcpy(yyval.c, ctime(&now));
      yyval.c[strlen(yyval.c) - 1] = '\0';
    ;
    break;}
case 350:
#line 3456 "Gmsh.y"
{
      yyval.c = (char *)Malloc((strlen(yyvsp[-3].c)+strlen(yyvsp[-1].c)+1)*sizeof(char));
      strcpy(yyval.c, yyvsp[-3].c);
      strcat(yyval.c, yyvsp[-1].c);
      Free(yyvsp[-3].c);
      Free(yyvsp[-1].c);
    ;
    break;}
case 351:
#line 3464 "Gmsh.y"
{
      yyval.c = (char *)Malloc((strlen(yyvsp[-1].c)+1)*sizeof(char));
      int i;
      for(i = strlen(yyvsp[-1].c)-1; i >= 0; i--){
	if(yyvsp[-1].c[i] == '.'){
	  strncpy(yyval.c, yyvsp[-1].c, i);
	  yyval.c[i]='\0';
	  break;
	}
      }
      if(i <= 0) strcpy(yyval.c, yyvsp[-1].c);
      Free(yyvsp[-1].c);
    ;
    break;}
case 352:
#line 3478 "Gmsh.y"
{
      yyval.c = (char *)Malloc((strlen(yyvsp[-1].c)+1)*sizeof(char));
      int i;
      for(i = strlen(yyvsp[-1].c)-1; i >= 0; i--){
	if(yyvsp[-1].c[i] == '/' || yyvsp[-1].c[i] == '\\')
	  break;
      }
      if(i <= 0)
	strcpy(yyval.c, yyvsp[-1].c);
      else
	strcpy(yyval.c, &yyvsp[-1].c[i+1]);
      Free(yyvsp[-1].c);
    ;
    break;}
case 353:
#line 3492 "Gmsh.y"
{
      yyval.c = yyvsp[-1].c;
    ;
    break;}
case 354:
#line 3496 "Gmsh.y"
{
      char tmpstring[1024];
      int i = PrintListOfDouble(yyvsp[-3].c, yyvsp[-1].l, tmpstring);
      if(i < 0){
	yymsg(GERROR, "Too few arguments in Sprintf");
	yyval.c = yyvsp[-3].c;
      }
      else if(i > 0){
	yymsg(GERROR, "%d extra argument%s in Sprintf", i, (i>1)?"s":"");
	yyval.c = yyvsp[-3].c;
      }
      else{
	yyval.c = (char*)Malloc((strlen(tmpstring)+1)*sizeof(char));
	strcpy(yyval.c, tmpstring);
	Free(yyvsp[-3].c);
      }
      List_Delete(yyvsp[-1].l);
    ;
    break;}
case 355:
#line 3515 "Gmsh.y"
{ 
      char* (*pStrOpt)(int num, int action, char *value);
      StringXString *pStrCat;
      if(!(pStrCat = Get_StringOptionCategory(yyvsp[-3].c))){
	yymsg(GERROR, "Unknown string option class '%s'", yyvsp[-3].c);
	yyval.c = (char*)Malloc(sizeof(char));
	yyval.c[0] = '\0';
      }
      else{
	if(!(pStrOpt = (char *(*) (int, int, char *))Get_StringOption(yyvsp[-1].c, pStrCat))){
	  yymsg(GERROR, "Unknown string option '%s.%s'", yyvsp[-3].c, yyvsp[-1].c);
	  yyval.c = (char*)Malloc(sizeof(char));
	  yyval.c[0] = '\0';
	}
	else{
	  char *str = pStrOpt(0, GMSH_GET, NULL);
	  yyval.c = (char*)Malloc((strlen(str)+1)*sizeof(char));
	  strcpy(yyval.c, str);
	}
      }
    ;
    break;}
case 356:
#line 3537 "Gmsh.y"
{ 
      char* (*pStrOpt)(int num, int action, char *value);
      StringXString *pStrCat;
      if(!(pStrCat = Get_StringOptionCategory(yyvsp[-6].c))){
	yymsg(GERROR, "Unknown string option class '%s'", yyvsp[-6].c);
	yyval.c = (char*)Malloc(sizeof(char));
	yyval.c[0] = '\0';
      }
      else{
	if(!(pStrOpt = (char *(*) (int, int, char *))Get_StringOption(yyvsp[-1].c, pStrCat))){
	  yymsg(GERROR, "Unknown string option '%s[%d].%s'", yyvsp[-6].c, (int)yyvsp[-4].d, yyvsp[-1].c);
	  yyval.c = (char*)Malloc(sizeof(char));
	  yyval.c[0] = '\0';
	}
	else{
	  char *str = pStrOpt((int)yyvsp[-4].d, GMSH_GET, NULL);
	  yyval.c = (char*)Malloc((strlen(str)+1)*sizeof(char));
	  strcpy(yyval.c, str);
	}
      }
    ;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 543 "/usr/share/bison.simple"

  yyvsp -= yylen;
  yyssp -= yylen;
#ifdef YYLSP_NEEDED
  yylsp -= yylen;
#endif

#if YYDEBUG != 0
  if (yydebug)
    {
      short *ssp1 = yyss - 1;
      fprintf (stderr, "state stack now");
      while (ssp1 != yyssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

  *++yyvsp = yyval;

#ifdef YYLSP_NEEDED
  yylsp++;
  if (yylen == 0)
    {
      yylsp->first_line = yylloc.first_line;
      yylsp->first_column = yylloc.first_column;
      yylsp->last_line = (yylsp-1)->last_line;
      yylsp->last_column = (yylsp-1)->last_column;
      yylsp->text = 0;
    }
  else
    {
      yylsp->last_line = (yylsp+yylen-1)->last_line;
      yylsp->last_column = (yylsp+yylen-1)->last_column;
    }
#endif

  /* Now "shift" the result of the reduction.
     Determine what state that goes to,
     based on the state we popped back to
     and the rule number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTBASE];

  goto yynewstate;

yyerrlab:   /* here on detecting error */

  if (! yyerrstatus)
    /* If not already recovering from an error, report this error.  */
    {
      ++yynerrs;

#ifdef YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (yyn > YYFLAG && yyn < YYLAST)
	{
	  int size = 0;
	  char *msg;
	  int x, count;

	  count = 0;
	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
	  for (x = (yyn < 0 ? -yyn : 0);
	       x < (sizeof(yytname) / sizeof(char *)); x++)
	    if (yycheck[x + yyn] == x)
	      size += strlen(yytname[x]) + 15, count++;
	  msg = (char *) malloc(size + 15);
	  if (msg != 0)
	    {
	      strcpy(msg, "parse error");

	      if (count < 5)
		{
		  count = 0;
		  for (x = (yyn < 0 ? -yyn : 0);
		       x < (sizeof(yytname) / sizeof(char *)); x++)
		    if (yycheck[x + yyn] == x)
		      {
			strcat(msg, count == 0 ? ", expecting `" : " or `");
			strcat(msg, yytname[x]);
			strcat(msg, "'");
			count++;
		      }
		}
	      yyerror(msg);
	      free(msg);
	    }
	  else
	    yyerror ("parse error; also virtual memory exceeded");
	}
      else
#endif /* YYERROR_VERBOSE */
	yyerror("parse error");
    }

  goto yyerrlab1;
yyerrlab1:   /* here on error raised explicitly by an action */

  if (yyerrstatus == 3)
    {
      /* if just tried and failed to reuse lookahead token after an error, discard it.  */

      /* return failure if at end of input */
      if (yychar == YYEOF)
	YYABORT;

#if YYDEBUG != 0
      if (yydebug)
	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif

      yychar = YYEMPTY;
    }

  /* Else will try to reuse lookahead token
     after shifting the error token.  */

  yyerrstatus = 3;		/* Each real token shifted decrements this */

  goto yyerrhandle;

yyerrdefault:  /* current state does not do anything special for the error token. */

#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */
  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (yyn) goto yydefault;
#endif

yyerrpop:   /* pop the current state because it cannot handle the error token */

  if (yyssp == yyss) YYABORT;
  yyvsp--;
  yystate = *--yyssp;
#ifdef YYLSP_NEEDED
  yylsp--;
#endif

#if YYDEBUG != 0
  if (yydebug)
    {
      short *ssp1 = yyss - 1;
      fprintf (stderr, "Error: state stack now");
      while (ssp1 != yyssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

yyerrhandle:

  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yyerrdefault;

  yyn += YYTERROR;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
    goto yyerrdefault;

  yyn = yytable[yyn];
  if (yyn < 0)
    {
      if (yyn == YYFLAG)
	goto yyerrpop;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrpop;

  if (yyn == YYFINAL)
    YYACCEPT;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting error token, ");
#endif

  *++yyvsp = yylval;
#ifdef YYLSP_NEEDED
  *++yylsp = yylloc;
#endif