генерация дефайнов, макросы препроцессора Опции

[SpiritDance]

А как бы так извернутся с препроцессором?

Требуется код примерно такого вида:

Код

/* знгачения идут по порядку от базового целого */
#define X1 1200
#define X2 1201
#define X3 1203
.....
#define XN 12..

/* A1 и A2 идут в начаеле и они разных значений */
const t_mytype X_struct_array =
{
   A1, 0, {0},
   A2, 0, {0},
   X1, 0, {0},
   X2, 0, {0},
   .....
   XN, 0, {0}
}

где N зависит от модели устройства

Вопрос в том как сделать, чтобы не набивать X1 X2.. Xn а просто задать количество N и код сгенерился бы препроцессором?
постоянно сталкиваюсь с такой проблемой, а решения так и не нашел. Хочется уже один раз разобратся и не терять больше времени на возню.
Извиняюсь если не в тот раздел, больше не нашел куда приткнуть.

[Непомнящий Евген...]

Можно посмотреть тут:
http://www.boostpro.com/tmpbook/preprocessor.html

Я не разбирался с ним плотно, вроде как примерно то. Если еще получится выдрать это из boost и присобачить к иару

А вообще может быть написать скрипт (на чем-нить типа питона\перла\пхп), который будет генерить нужный вам файл. Этот вариант дает максимальную свободу. Я таким образом обрабатываю строковые константы.

Еще можно посмотреть на более мощные препроцессоры типа M4. Но (имхо) вариант со скриптом проще.

[MrYuran]

#define X(i) (1199+i)

[SpiritDance]

#define X(i) (1199+i)

Угу гениально И как этим пользоватся?
Вот так?

Код

#define X1   X(1)
#define X2   X(2)
#define X3   X(3)

За буст спасибо конечно, но по моему отцепить предлагаемое от шаблонов или хотя бы от библиотеки невозможно.(у меня мозгов не хватит точно ) А нужно С без плюсов.

Есть еще варианты? или только скриптовый язык типа перла?

[MrYuran]

И как этим пользоватся?
Вот так?

Нет, не так. Верхний блок заменяется одним дефайном, а уж нижний... фантазии не хватает.
Да ладно, это я так написал, пальцы размять после выходных

[vmp]

Можно чуть-чуть сократить количество писанины путем применения enum:
typedef enum {
X1 = 1201, X2, X3, X4, ..., XN} T_XX;

Дальше для генерации можно взять препроцессор, оператор ##:
#define GEN10(str) str##0, str##1, str##2 и т.д до str##9
тогда вызов GEN10(X5) сделает перечисление X50, X51, X52, ... X59

[Rst7]

Если не пугает небольшая кривость, то можно сделать так

Код

typedef struct
{
  int val;
}t_mytype;

#define XNEXT (__LINE__+1200)
const t_mytype X_struct_array[] = {
#include "x.h"
};

и файл x.h

Код

  {XNEXT},
  {XNEXT},
  {XNEXT},
  {XNEXT},
  {XNEXT},
  {XNEXT},
  {XNEXT},
  {XNEXT},
  {XNEXT},

Естественно, на x.h накладываются ограничения: одна строка - один элемент, пропусков быть не должно.

Результат после препроцессора таков:

Код

typedef struct
{
  int val;
}t_mytype;

const t_mytype X_struct_array[] = {
  {(1+1200)},
  {(2+1200)},
  {(3+1200)},
  {(4+1200)},
  {(5+1200)},
  {(6+1200)},
  {(7+1200)},
  {(8+1200)},
  {(9+1200)},
};

[vet]

где N зависит от модели устройства

Вопрос в том как сделать, чтобы не набивать X1 X2.. Xn а просто задать количество N и код сгенерился бы препроцессором?

Можно единожды сделать общий для всех устройств исходник, для большого N, с запасом, затем расставить #ifdef для разных устройств.
Последовательность чисел произвольной длины делается в экселе одним движением мыши.

Код

#if defined(DEVICE1)  || defined(DEVICE2) || defined(DEVICE3)
#define X1 1201
#define X2 1202
#endif
#if defined(DEVICE2) || defined(DEVICE3)
#define X3 1203
#define X4 1204
#endif
#if defined(DEVICE3)
#define X5 1205
#define X6 1206
#endif

[vmp]

Лови решение для N < 100. Единственный недостаток - что N нужно разбивать на единицы и десятки вручную. Проверен на IAR C для ARM.
Пример для N=73:

Код

//#define ITEM(n) X##n
// Генерация единиц - служебные макросы
#define GEN0(n)
#define GEN1(n)  ITEM(n##0)
#define GEN2(n)  ITEM(n##0),ITEM(n##1)
#define GEN3(n)  ITEM(n##0),ITEM(n##1),ITEM(n##2)
#define GEN4(n)  ITEM(n##0),ITEM(n##1),ITEM(n##2),ITEM(n##3)
#define GEN5(n)  ITEM(n##0),ITEM(n##1),ITEM(n##2),ITEM(n##3),ITEM(n##4)
#define GEN6(n)  ITEM(n##0),ITEM(n##1),ITEM(n##2),ITEM(n##3),ITEM(n##4),ITEM(n##5)
#define GEN7(n)  ITEM(n##0),ITEM(n##1),ITEM(n##2),ITEM(n##3),ITEM(n##4),ITEM(n##5),ITEM(n##6)
#define GEN8(n)  ITEM(n##0),ITEM(n##1),ITEM(n##2),ITEM(n##3),ITEM(n##4),ITEM(n##5),ITEM(n##6),ITEM(n##7)
#define GEN9(n)  ITEM(n##0),ITEM(n##1),ITEM(n##2),ITEM(n##3),ITEM(n##4),ITEM(n##5),ITEM(n##6),ITEM(n##7),ITEM(n##8)
#define GEN10(n) ITEM(n##0),ITEM(n##1),ITEM(n##2),ITEM(n##3),ITEM(n##4),ITEM(n##5),ITEM(n##6),ITEM(n##7),ITEM(n##8),ITEM(n##9)

// Генерация десятков - служебные макросы
#define GEND0(n)
#define GEND1(n)  GEN10(n##0)
#define GEND2(n)  GEN10(n##0),GEN10(n##1)
#define GEND3(n)  GEN10(n##0),GEN10(n##1),GEN10(n##2)
#define GEND4(n)  GEN10(n##0),GEN10(n##1),GEN10(n##2),GEN10(n##3)
#define GEND5(n)  GEN10(n##0),GEN10(n##1),GEN10(n##2),GEN10(n##3),GEN10(n##4)
#define GEND6(n)  GEN10(n##0),GEN10(n##1),GEN10(n##2),GEN10(n##3),GEN10(n##4),GEN10(n##5)
#define GEND7(n)  GEN10(n##0),GEN10(n##1),GEN10(n##2),GEN10(n##3),GEN10(n##4),GEN10(n##5),GEN10(n##6)
#define GEND8(n)  GEN10(n##0),GEN10(n##1),GEN10(n##2),GEN10(n##3),GEN10(n##4),GEN10(n##5),GEN10(n##6),GEN10(n##7)
#define GEND9(n)  GEN10(n##0),GEN10(n##1),GEN10(n##2),GEN10(n##3),GEN10(n##4),GEN10(n##5),GEN10(n##6),GEN10(n##7),GEN10(n##8)
#define GEND10(n) GEN10(n##0),GEN10(n##1),GEN10(n##2),GEN10(n##3),GEN10(n##4),GEN10(n##5),GEN10(n##6),GEN10(n##7),GEN10(n##8),GEN10(n##9)

// А вот это надо вызывать для генерации кода
#define GEND(d,s,n) GEND##d(n),GEN##s(n##d)

// Макрос, генерящий одну запись. Надо переопределять
#define ITEM(n) X##n

typedef enum {
Xm1 = 1199,
GEND(7,3,)} T_XX;

typedef struct {
T_XX x;
int a, b;
} T_MS;

// Еще одна генерация
#undef ITEM
#define ITEM(n) {X##n, 0, 0}

const T_MS zzz[] = {
{Xm1, 0},
{Xm1, 0},
GEND(7,3,)
};