コード例 #1
0
/**
**	Parse unit-type.
**
**	@param list	List describing missile.
*/
local SCM CclUnitType(SCM list)
{
    SCM value;
    int type;

    return list;

    //	Slot
    value=gh_car(list);
    type=gh_scm2int(value);
    list=gh_cdr(list);
    DebugLevel3("UnitType: %d\n",type);

    //	Name
    value=gh_car(list);
    UnitTypes[type].Name=gh_scm2newstr(value,NULL);
    list=gh_cdr(list);

    //	Graphics
    value=gh_car(list);

    //	FIXME: more ...

    return list;
}
コード例 #2
0
ファイル: ccl_player.c プロジェクト: hhirsch/open_conflict
/**
**	Define race mapping from original number to internal symbol
**
**	@param list	List of all names.
*/
local SCM CclDefineRaceWcNames(SCM list)
{
    int i;
    char** cp;

    if( (cp=RaceWcNames) ) {		// Free all old names
	while( *cp ) {
	    free(*cp++);
	}
	free(RaceWcNames);
    }

    //
    //	Get new table.
    //
    i=gh_length(list);
    RaceWcNames=cp=malloc((i+1)*sizeof(char*));
    while( i-- ) {
	*cp++=gh_scm2newstr(gh_car(list),NULL);
	list=gh_cdr(list);
    }
    *cp=NULL;

    return SCM_UNSPECIFIED;
}
コード例 #3
0
void
GridMapData::parse_from_file (SCM desc)
{
  /* GridMaps will always get a one pixel boarder with the base
     enviroment */
  char* str = gh_scm2newstr(gh_car (desc), 0);
  std::cout << "Loading from: " << str << std::endl;
  std::string filename = str;
#ifndef WIN32
  free (str);
#endif

  provider = CL_PNGProvider (path_manager.complete("missions/" + filename));

  provider.lock ();
  //FIXME:Display2 assert (provider.is_indexed ());

  grid_width  = provider.get_width () + 2;
  grid_height = provider.get_height () + 2;

  grid_data.resize (grid_width * grid_height);
  
  for (int i = 0; i < grid_height * grid_width; ++i)
    grid_data[i] = GT_SAND; // FIXME: should be variable not hardcoded!

  unsigned char* buffer = static_cast<unsigned char*>(provider.get_data ());
  for (int y = 0; y < provider.get_height (); ++y)
    for (int x = 0; x < provider.get_width (); ++x)
      grid_data[(x + 1) + ((y+1) * grid_width)] 
	= static_cast<GroundType>(buffer[x + (provider.get_width () * y)]);

  provider.unlock (); 
}
コード例 #4
0
InputAxis* 
AxisFactory::create(SCM lst)
{
  while(gh_pair_p(lst))
    {
      SCM sym  = gh_car(lst);
      SCM data = gh_cdr(lst);
      
      if (gh_equal_p(sym, gh_symbol2scm("joystick-axis")))
        {
          return create_joystick_axis(data);
        }
      if (gh_equal_p(sym, gh_symbol2scm("button-axis")))
        {
          return create_button_axis(data);
        }
      else
        {
          throw FeuerkraftError("AxisFactory::create: parse error");
        }

      lst = gh_cdr(lst);
    }
  return 0;
}
コード例 #5
0
/**
**  Dump some AI debug informations.
**
**  @param l  Lua state.
*/
static int CclAiDump(lua_State *l)
{
	LuaCheckArgs(l, 0);
	//
	// Script
	//
	printf("------\n");
	for (int i = 0; i < MaxCosts; ++i) {
		printf("%s(%4d) ", DefaultResourceNames[i].c_str(), AiPlayer->Player->Resources[i]);
	}
	printf("\n");
	printf("%d:", AiPlayer->Player->Index);
#if 0
	gh_display(gh_car(AiPlayer->Script));
#endif
	//
	// Requests
	//
	size_t n = AiPlayer->UnitTypeRequests.size();
	printf("UnitTypeRequests(%u):\n", static_cast<unsigned int>(n));
	for (size_t i = 0; i < n; ++i) {
		printf("%s ", AiPlayer->UnitTypeRequests[i].Type->Ident.c_str());
	}
	printf("\n");
	n = AiPlayer->UpgradeToRequests.size();
	printf("UpgradeToRequests(%u):\n", static_cast<unsigned int>(n));
	for (size_t i = 0; i < n; ++i) {
		printf("%s ", AiPlayer->UpgradeToRequests[i]->Ident.c_str());
	}
	printf("\n");
	n = AiPlayer->ResearchRequests.size();
	printf("ResearchRequests(%u):\n", static_cast<unsigned int>(n));
	for (size_t i = 0; i < n; ++i) {
		printf("%s ", AiPlayer->ResearchRequests[i]->Ident.c_str());
	}
	printf("\n");

	// Building queue
	printf("Building queue:\n");
	for (size_t i = 0; i < AiPlayer->UnitTypeBuilt.size(); ++i) {
		const AiBuildQueue &queue = AiPlayer->UnitTypeBuilt[i];
		printf("%s(%d/%d) ", queue.Type->Ident.c_str(), queue.Made, queue.Want);
	}
	printf("\n");

	// PrintForce
	for (size_t i = 0; i < AiPlayer->Force.Size(); ++i) {
		printf("Force(%u%s%s):\n", static_cast<unsigned int>(i),
			   AiPlayer->Force[i].Completed ? ",complete" : ",recruit",
			   AiPlayer->Force[i].Attacking ? ",attack" : "");
		for (size_t j = 0; j < AiPlayer->Force[i].UnitTypes.size(); ++j) {
			const AiUnitType &aut = AiPlayer->Force[i].UnitTypes[j];
			printf("%s(%d) ", aut.Type->Ident.c_str(), aut.Want);
		}
		printf("\n");
	}
	lua_pushboolean(l, 0);
	return 1;
}
コード例 #6
0
InputAxis*
AxisFactory::create_button_axis(SCM lst)
{
  InputButton* left  = ButtonFactory::create(gh_car(lst));
  InputButton* right = ButtonFactory::create(gh_cadr(lst));

  return new ButtonAxis(left, right);
}
コード例 #7
0
InputAxis*
AxisFactory::create_joystick_axis(SCM lst)
{
  int device_num = gh_scm2int(gh_car(lst));
  int axis_num   = gh_scm2int(gh_cadr(lst));

  if (device_num >= 0 && device_num < CL_Joystick::get_device_count())
    return new InputAxisInputDevice(CL_Joystick::get_device(device_num), axis_num);
  else
    {
      throw FeuerkraftError("Error: AxisFactory::create_joystick_axis: " 
                            + Guile::scm2string(lst));
      return 0;
    }
}
コード例 #8
0
ファイル: ccl.c プロジェクト: saniv/freecraft-ale-clone
/**
**	Parse missile-type.
**
**	@param list	List describing missile.
*/
local SCM CclMissileType(SCM list)
{
    SCM value;
    int type;

    //	Slot
    value=gh_car(list);
    type=gh_scm2int(value);
    if( type>=MissileTypeMax ) {
	fprintf(stderr,"Wrong type %d\n",type);
	return list;
    }
    list=gh_cdr(list);
    DebugLevel3("MissileType: %d\n",type);

    //	Name
    value=gh_car(list);
    MissileTypes[type].Name=gh_scm2newstr(value,NULL);
    list=gh_cdr(list);

    //	File
    value=gh_car(list);
    MissileTypes[type].File=gh_scm2newstr(value,NULL);
    list=gh_cdr(list);

    // Width,Height
    value=gh_car(list);
    MissileTypes[type].Width=gh_scm2int(value);
    list=gh_cdr(list);
    value=gh_car(list);
    MissileTypes[type].Height=gh_scm2int(value);
    list=gh_cdr(list);

    // Sound impact
    value=gh_car(list);
#ifdef WITH_SOUND
    if (ccl_sound_p(value)) {
	MissileTypes[type].ImpactSound.Sound=ccl_sound_id(value);
    } else
#endif
    if (!gh_boolean_p(value) ||  gh_scm2bool(value) ) {
	fprintf(stderr,"Wrong argument in MissileType\n");
    }
    list=gh_cdr(list);

    // FIXME: class, speed not written!!!

    return list;
}
コード例 #9
0
ファイル: font.c プロジェクト: saniv/freecraft-ale-clone
/**
**	Define the used font colors.
*/
local SCM CclDefineFontColors(SCM list)
{
    int i;
    int j;
    SCM value;
    SCM temp;

    for (i = 0; i < 16; ++i) {
	value = gh_car(list);
	list = gh_cdr(list);

	if (gh_vector_length(value) != 7) {
	    fprintf(stderr, "Wrong vector length\n");
	}
	for (j = 0; j < 7; ++j) {
	    temp = gh_vector_ref(value, gh_int2scm(j));
	    FontColors[i][j] = gh_scm2int(temp);
	}
    }

    return SCM_UNSPECIFIED;
}
コード例 #10
0
int
building_create_type(const char* name, SCM lst)
{
  AList alist;
  
  while(!gh_null_p(lst))
    {
      SCM key   = gh_car(lst);

      if (gh_null_p(gh_cdr(lst)))
        {
          std::cout << "Missing argument to keyword!" << std::endl;
        }

      SCM value = gh_cadr(lst);

      if (gh_boolean_p(value))
        {
          alist.set_bool(Guile::keyword2string(key), gh_scm2bool(value));
        }
      else if (gh_number_p(value))
        {
          alist.set_int(Guile::keyword2string(key), gh_scm2int(value));
        }
      else if (gh_string_p(value))
        {
          alist.set_string(Guile::keyword2string(key), Guile::scm2string(value));
        }
      else
        {
          std::cout << "BuildingCommands: unknown argumnent type" << std::endl;
        }

      lst = gh_cddr(lst);
    }

  return BuildingTypeManager::current()->register_factory(new CustomBuildingFactory(name, alist));
}
コード例 #11
0
ファイル: ccl_player.c プロジェクト: hhirsch/open_conflict
/**
**	Parse the player configuration.
**
**	@param list	Tagged list of all informations.
*/
local SCM CclPlayer(SCM list)
{
    SCM value;
    SCM sublist;
    Player* player;
    int i;
    char* str;

    i=gh_scm2int(gh_car(list));
    player=&Players[i];
    if( NumPlayers<=i ) {
	NumPlayers=i+1;
    }
    player->Player = i;
    player->Color=PlayerColors[i];
    if( !(player->Units=(Unit**)calloc(UnitMax,sizeof(Unit*))) ) {
	DebugLevel0("Not enough memory to create player %d.\n" _C_ i);

	return SCM_UNSPECIFIED;
    }
    list=gh_cdr(list);

    //
    //	Parse the list:	(still everything could be changed!)
    //
    while( !gh_null_p(list) ) {

	value=gh_car(list);
	list=gh_cdr(list);

	if( gh_eq_p(value,gh_symbol2scm("name")) ) {
	    player->Name=gh_scm2newstr(gh_car(list),NULL);
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("type")) ) {
	    value=gh_car(list);
	    list=gh_cdr(list);
	    if( gh_eq_p(value,gh_symbol2scm("neutral")) ) {
		player->Type=PlayerNeutral;
	    } else if( gh_eq_p(value,gh_symbol2scm("nobody")) ) {
		player->Type=PlayerNobody;
	    } else if( gh_eq_p(value,gh_symbol2scm("computer")) ) {
		player->Type=PlayerComputer;
	    } else if( gh_eq_p(value,gh_symbol2scm("person")) ) {
		player->Type=PlayerPerson;
	    } else if( gh_eq_p(value,gh_symbol2scm("rescue-passive")) ) {
		player->Type=PlayerRescuePassive;
	    } else if( gh_eq_p(value,gh_symbol2scm("rescue-active")) ) {
		player->Type=PlayerRescueActive;
	    } else {
	       // FIXME: this leaves a half initialized player
	       errl("Unsupported tag",value);
	    }
	} else if( gh_eq_p(value,gh_symbol2scm("race")) ) {
	    str=gh_scm2newstr(gh_car(list),NULL);
	    if( RaceWcNames ) {
		for( i=0; RaceWcNames[i]; ++i ) {
		    if( !strcmp(str,RaceWcNames[i]) ) {
			player->RaceName=RaceWcNames[i];
			player->Race=i;
			break;
		    }
		}
	    }
	    free(str);
	    if( !RaceWcNames || !RaceWcNames[i] ) {
	       // FIXME: this leaves a half initialized player
	       errl("Unsupported tag",gh_car(list));
	    }
#if 0
	    player->RaceName=str=gh_scm2newstr(gh_car(list),NULL);
	    if( !strcmp(str,"human") ) {
		player->Race=PlayerRaceHuman;
	    } else if( !strcmp(str,"orc") ) {
		player->Race=PlayerRaceOrc;
	    } else if( !strcmp(str,"neutral") ) {
		player->Race=PlayerRaceNeutral;
	    } else {
	       // FIXME: this leaves a half initialized player
	       errl("Unsupported tag",gh_car(list));
	    }
#endif
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("ai")) ) {
	    player->AiNum=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("team")) ) {
	    player->Team=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("enemy")) ) {
	    str=gh_scm2newstr(gh_car(list),NULL);
	    list=gh_cdr(list);
	    for( i=0; i<PlayerMax && *str; ++i,++str ) {
		if( *str=='-' || *str=='_' || *str==' ' ) {
		    player->Enemy&=~(1<<i);
		} else {
		    player->Enemy|=(1<<i);
		}
	    }
	} else if( gh_eq_p(value,gh_symbol2scm("allied")) ) {
	    str=gh_scm2newstr(gh_car(list),NULL);
	    list=gh_cdr(list);
	    for( i=0; i<PlayerMax && *str; ++i,++str ) {
		if( *str=='-' || *str=='_' || *str==' ' ) {
		    player->Allied&=~(1<<i);
		} else {
		    player->Allied|=(1<<i);
		}
	    }
	} else if( gh_eq_p(value,gh_symbol2scm("shared-vision")) ) {
	    str=gh_scm2newstr(gh_car(list),NULL);
	    list=gh_cdr(list);
	    for( i=0; i<PlayerMax && *str; ++i,++str ) {
		if( *str=='-' || *str=='_' || *str==' ' ) {
		    player->SharedVision&=~(1<<i);
		} else {
		    player->SharedVision|=(1<<i);
		}
	    }
	} else if( gh_eq_p(value,gh_symbol2scm("start")) ) {
	    value=gh_car(list);
	    list=gh_cdr(list);
	    player->StartX=gh_scm2int(gh_car(value));
	    player->StartY=gh_scm2int(gh_cadr(value));
	} else if( gh_eq_p(value,gh_symbol2scm("resources")) ) {
	    sublist=gh_car(list);
	    list=gh_cdr(list);
	    while( !gh_null_p(sublist) ) {

		value=gh_car(sublist);
		sublist=gh_cdr(sublist);

		for( i=0; i<MaxCosts; ++i ) {
		    if( gh_eq_p(value,gh_symbol2scm((char*)DefaultResourceNames[i])) ) {
			player->Resources[i]=gh_scm2int(gh_car(sublist));
			break;
		    }
		}
		if( i==MaxCosts ) {
		   // FIXME: this leaves a half initialized player
		   errl("Unsupported tag",value);
		}
		sublist=gh_cdr(sublist);
	    }
	} else if( gh_eq_p(value,gh_symbol2scm("incomes")) ) {
	    sublist=gh_car(list);
	    list=gh_cdr(list);
	    while( !gh_null_p(sublist) ) {

		value=gh_car(sublist);
		sublist=gh_cdr(sublist);

		for( i=0; i<MaxCosts; ++i ) {
		    if( gh_eq_p(value,gh_symbol2scm((char*)DefaultResourceNames[i])) ) {
			player->Incomes[i]=gh_scm2int(gh_car(sublist));
			break;
		    }
		}
		if( i==MaxCosts ) {
		   // FIXME: this leaves a half initialized player
		   errl("Unsupported tag",value);
		}
		sublist=gh_cdr(sublist);
	    }
	} else if( gh_eq_p(value,gh_symbol2scm("ai-enabled")) ) {
	    player->AiEnabled=1;
	} else if( gh_eq_p(value,gh_symbol2scm("ai-disabled")) ) {
	    player->AiEnabled=0;
	} else if( gh_eq_p(value,gh_symbol2scm("food")) ) {
	    player->Food=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("food-unit-limit")) ) {
	    player->FoodUnitLimit=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("building-limit")) ) {
	    player->BuildingLimit=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("total-unit-limit")) ) {
	    player->TotalUnitLimit=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("score")) ) {
	    player->Score=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("total-units")) ) {
	    player->TotalUnits=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("total-buildings")) ) {
	    player->TotalBuildings=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("total-razings")) ) {
	    player->TotalRazings=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("total-kills")) ) {
	    player->TotalKills=gh_scm2int(gh_car(list));
	    list=gh_cdr(list);
	} else if( gh_eq_p(value,gh_symbol2scm("total-resources")) ) {
	    sublist=gh_car(list);
	    list=gh_cdr(list);
	    i=gh_length(sublist);
	    if( i!=MaxCosts ) {
		fprintf(stderr,"Wrong number of total-resources %d\n",i);
	    }
	    i=0;
	    while( !gh_null_p(sublist) ) {
		if( i<MaxCosts ) {
		    player->TotalResources[i]=gh_scm2int(gh_car(sublist));
		}
		sublist=gh_cdr(sublist);
		++i;
	    }
	    player->TotalUnits=gh_scm2int(gh_car(list));
	} else if( gh_eq_p(value,gh_symbol2scm("timers")) ) {
	    sublist=gh_car(list);
	    list=gh_cdr(list);
	    i=gh_length(sublist);
	    if( i!=UpgradeMax ) {
		fprintf(stderr,"Wrong upgrade timer length %d\n",i);
	    }

	    i=0;
	    while( !gh_null_p(sublist) ) {
		if( i<UpgradeMax ) {
		    player->UpgradeTimers.Upgrades[i]=
			    gh_scm2int(gh_car(sublist));
		}
		sublist=gh_cdr(sublist);
		++i;
	    }
	} else {
	   // FIXME: this leaves a half initialized player
	   errl("Unsupported tag",value);
	}
    }

    return SCM_UNSPECIFIED;
}
コード例 #12
0
ファイル: ccl.c プロジェクト: saniv/freecraft-ale-clone
/**
**	Parse a clone map.
**
**	@param list	list of tuples keyword data
*/
local SCM CclCloneMap(SCM list)
{
    SCM value;
    SCM name;
    SCM data;

    //
    //	Parse the list:	(still everything could be changed!)
    //
    while( !gh_null_p(list) ) {

	value=gh_car(list);
	//gh_display(value);
	//gh_newline();
	if( gh_list_p(value) ) {
	    name=gh_car(value);
	    data=gh_cdr(value);
	    if( !gh_symbol_p(name) ) {
		fprintf(stderr,"symbol expected\n");
		return list;
	    }
	    if( gh_eq_p(name,gh_symbol2scm("version")) ) {
		DebugLevel1("VERSION:\n");
		gh_display(data);
		gh_newline();
		// FIXME:
	    } else if( gh_eq_p(name,gh_symbol2scm("description")) ) {
		DebugLevel1("DESCRIPTION:\n");
		gh_display(data);
		gh_newline();
		// FIXME:
	    } else if( gh_eq_p(name,gh_symbol2scm("terrain")) ) {
		int terrain;

		DebugLevel1("TERRAIN:\n");
		gh_display(data);
		gh_newline();
		value=gh_car(data);
		data=gh_cdr(data);
		terrain=gh_scm2int(value);
		TheMap.Terrain=terrain;
		// FIXME:
	    } else if( gh_eq_p(name,gh_symbol2scm("dimension")) ) {
		int width;
		int height;

		DebugLevel1("DIMENSION:\n");
		gh_display(data);
		gh_newline();
		value=gh_car(data);
		width=gh_scm2int(value);
		data=gh_cdr(data);
		value=gh_car(data);
		height=gh_scm2int(value);
		TheMap.Width=width;
		TheMap.Height=height;

		TheMap.Fields=calloc(width*height,sizeof(*TheMap.Fields));
		InitUnitCache();

	    } else if( gh_eq_p(name,gh_symbol2scm("tiles")) ) {
		int i;
		int l;

		DebugLevel1("TILES:\n");
		value=gh_car(data);
		if( !gh_vector_p(value) ) {
		    fprintf(stderr,"vector expected\n");
		    return SCM_UNSPECIFIED;
		}
		l=gh_vector_length(value);
		if( l!=TheMap.Width*TheMap.Height ) {
		    fprintf(stderr,"Wrong tile table length %d\n",l);
		}
		for( i=0; i<l; ++i ) {
		    TheMap.Fields[i].Tile=
			    Tilesets[TilesetSummer].Table[
				gh_scm2int(gh_vector_ref(value,gh_int2scm(i)))
			    ];
		}
	    } else {
		;
	    }
	} else {
	    fprintf(stderr,"list expected\n");
	    return list;
	}

	list=gh_cdr(list);
    }

    return list;
}
コード例 #13
0
ファイル: construct.c プロジェクト: saniv/freecraft-ale-clone
/**
**	Parse the construction.
**
**	@param list	List describing the construction.
**
**	@note make this more flexible
*/
local SCM CclDefineConstruction(SCM list)
{
    SCM value;
    SCM sublist;
    char* str;
    Construction* construction;
    Construction** cop;
    int i;

    //	Slot identifier

    str=gh_scm2newstr(gh_car(list),NULL);
    list=gh_cdr(list);

    for( i=0; ConstructionWcNames[i]; ++i ) {
        if( !strcmp(ConstructionWcNames[i],str) ) {
            break;
        }
    }
    if( !ConstructionWcNames[i] ) {
        DebugLevel0Fn("Construction not found.\n");
        free(str);
        return SCM_UNSPECIFIED;
    }

    if( (cop=Constructions)==NULL ) {
        Constructions=malloc(2*sizeof(Construction*));
        Constructions[0]=calloc(1,sizeof(Construction));
        Constructions[1]=NULL;
        construction=Constructions[0];
    } else {
        for( i=0; *cop; ++i,++cop ) {
        }
        Constructions=realloc(Constructions,(i+2)*sizeof(Construction*));
        Constructions[i]=calloc(1,sizeof(Construction));
        Constructions[i+1]=NULL;
        construction=Constructions[i];
    }
    construction->OType=ConstructionType;
    construction->Ident=str;

    //
    //	Parse the arguments, in tagged format.
    //
    while( !gh_null_p(list) ) {
        value=gh_car(list);
        list=gh_cdr(list);
        if( gh_eq_p(value,gh_symbol2scm("files")) ) {
            sublist=gh_car(list);

            //
            //	Parse the tilesets
            //
            while( !gh_null_p(sublist) ) {
                str=gh_scm2newstr(gh_car(sublist),NULL);

                // FIXME: use a general get tileset function here!
                i=0;
                if( strcmp(str,"default") ) {
                    for( ; i<NumTilesets; ++i ) {
                        if( !strcmp(str,Tilesets[i]->Ident) ) {
                            break;
                        }
                        if( !strcmp(str,Tilesets[i]->Class) ) {
                            break;
                        }
                    }
                    if( i==NumTilesets ) {
                        fprintf(stderr,"Tileset `%s' not available\n",str);
                        errl("tileset not available",gh_car(sublist));
                    }
                }
                sublist=gh_cdr(sublist);
                free(str);
                free(construction->File[i]);
                construction->File[i]=gh_scm2newstr(gh_car(sublist),NULL);
                sublist=gh_cdr(sublist);
            }

        } else if( gh_eq_p(value,gh_symbol2scm("size")) ) {
            value=gh_car(list);
            construction->Width=gh_scm2int(gh_car(value));
            value=gh_cdr(value);
            construction->Height=gh_scm2int(gh_car(value));

        } else if( gh_eq_p(value,gh_symbol2scm("shadow")) ) {
            sublist=gh_car(list);
            while( !gh_null_p(sublist) ) {
                value=gh_car(sublist);
                sublist=gh_cdr(sublist);

                if( gh_eq_p(value,gh_symbol2scm("file")) ) {
                    construction->ShadowFile=gh_scm2newstr(gh_car(sublist),NULL);
                } else if( gh_eq_p(value,gh_symbol2scm("width")) ) {
                    construction->ShadowWidth=gh_scm2int(gh_car(sublist));
                } else if( gh_eq_p(value,gh_symbol2scm("height")) ) {
                    construction->ShadowHeight=gh_scm2int(gh_car(sublist));
                } else {
                    errl("Unsupported shadow tag",value);
                }
                sublist=gh_cdr(sublist);
            }
        } else {
            // FIXME: this leaves a half initialized construction
            errl("Unsupported tag",value);
        }
        list=gh_cdr(list);
    }

    return SCM_UNSPECIFIED;
}
コード例 #14
0
ファイル: gh.c プロジェクト: SawfishWM/librep
repv gh_cddar(repv x)
{
    return gh_cdr (gh_cdr (gh_car (x)));
}
コード例 #15
0
ファイル: gh.c プロジェクト: SawfishWM/librep
repv gh_caaar(repv x)
{
    return gh_car (gh_car (gh_car (x)));
}