Eclipse includiert alle *.c dateien aus linked folder /lib

[Tom S. (tomsawer)]

Hallo!

Umgebung:

Linux Mint 64
Eclipse Indigo
AVR-GCC
AVR Eclipse Plugin

- Ich habe eine "AVR static Library" namens "lib" angelegt
- In diesem liegt eine tool.h und eine tool.cpp Datei
- Die tool.cpp Datei includiert den Header

---

In einem neuen "AVR Cross Target Platform" Projekt namens "Taiwan_board" 
packe ich "lib"-Ordner zu den C++ include directories und zu der "Source 
Location" (Siehe Foto)

--------

Das Problem:

Der Compiler kompiliert immer alle .cpp Dateien aus der externen /lib 
auch wenn ich die Header gar nicht includiere, also kein 'include 
<tool.h>

Dadurch werden MAKROS gesetzt und unnötiger Code erzeugt.

Mit der avr_libc funktioniert es ja auch, das nur kompiliert wird, was 
man auch benutzt.
Ich bin noch zu sehr ANfänger als das ich die Einstellung finde.. Hab 
Stunden gesucht.

Hier noch die makefile:

################################################################################
# Automatically-generated file. Do not edit!
################################################################################

-include ../makefile.init

RM := rm -rf

# All of the sources participating in the build are defined here
-include sources.mk
-include src/subdir.mk
-include library/subdir.mk
-include lib/Debug/subdir.mk
-include lib/subdir.mk
-include subdir.mk
-include objects.mk

ifneq ($(MAKECMDGOALS),clean)
ifneq ($(strip $(C++_DEPS)),)
-include $(C++_DEPS)
endif
ifneq ($(strip $(C_DEPS)),)
-include $(C_DEPS)
endif
ifneq ($(strip $(ASM_DEPS)),)
-include $(ASM_DEPS)
endif
ifneq ($(strip $(CC_DEPS)),)
-include $(CC_DEPS)
endif
ifneq ($(strip $(CPP_DEPS)),)
-include $(CPP_DEPS)
endif
ifneq ($(strip $(S_DEPS)),)
-include $(S_DEPS)
endif
ifneq ($(strip $(CXX_DEPS)),)
-include $(CXX_DEPS)
endif
ifneq ($(strip $(C_UPPER_DEPS)),)
-include $(C_UPPER_DEPS)
endif
ifneq ($(strip $(S_UPPER_DEPS)),)
-include $(S_UPPER_DEPS)
endif
endif

-include ../makefile.defs

# Add inputs and outputs from these tool invocations to the build variables 
LSS += \
Taiwan_BOard.lss \

FLASH_IMAGE += \
Taiwan_BOard.hex \

EEPROM_IMAGE += \
Taiwan_BOard.eep \

SIZEDUMMY += \
sizedummy \


# All Target
all: Taiwan_BOard.elf secondary-outputs

# Tool invocations
Taiwan_BOard.elf: $(OBJS) $(USER_OBJS)
  @echo 'Building target: $@'
  @echo 'Invoking: AVR C++ Linker'
  avr-g++ -Wl,-Map,Taiwan_BOard.map,--cref -mmcu=atmega128 -o "Taiwan_BOard.elf" $(OBJS) $(USER_OBJS) $(LIBS)
  @echo 'Finished building target: $@'
  @echo ' '

Taiwan_BOard.lss: Taiwan_BOard.elf
  @echo 'Invoking: AVR Create Extended Listing'
  -avr-objdump -h -S Taiwan_BOard.elf  >"Taiwan_BOard.lss"
  @echo 'Finished building: $@'
  @echo ' '

Taiwan_BOard.hex: Taiwan_BOard.elf
  @echo 'Create Flash image (ihex format)'
  -avr-objcopy -R .eeprom -O ihex Taiwan_BOard.elf  "Taiwan_BOard.hex"
  @echo 'Finished building: $@'
  @echo ' '

Taiwan_BOard.eep: Taiwan_BOard.elf
  @echo 'Create eeprom image (ihex format)'
  -avr-objcopy -j .eeprom --no-change-warnings --change-section-lma .eeprom=0 -O ihex Taiwan_BOard.elf  "Taiwan_BOard.eep"
  @echo 'Finished building: $@'
  @echo ' '

sizedummy: Taiwan_BOard.elf
  @echo 'Invoking: Print Size'
  -avr-size --format=avr --mcu=atmega128 Taiwan_BOard.elf
  @echo 'Finished building: $@'
  @echo ' '

# Other Targets
clean:
  -$(RM) $(OBJS)$(C_DEPS)$(EEPROM_IMAGE)$(ELFS)$(FLASH_IMAGE)$(LSS)$(S_DEPS)$(CXX_DEPS)$(S_UPPER_DEPS)$(C++_DEPS)$(ASM_DEPS)$(CC_DEPS)$(CPP_DEPS)$(C_UPPER_DEPS)$(SIZEDUMMY) Taiwan_BOard.elf
  -@echo ' '

secondary-outputs: $(LSS) $(FLASH_IMAGE) $(EEPROM_IMAGE) $(SIZEDUMMY)

.PHONY: all clean dependents
.SECONDARY:

-include ../makefile.targets

[Tom S. (tomsawer)]

Es muss irgendeinen MEchanismus geben, der nur die .c und .cpp Dateien 
kompiliert, die man verwendet. Wie heißt das und wo findet man es?

[Dirk (Gast)]

Hallo, such mal in den Projekteinstellungen (Projekt > re. Maustaste) 
nach "Include bzw. Exclude from build".

Grüße, Dirk

[Tom S. (tomsawer)]

Danke Dirk!
Das geht schonmal

Alternativ könnte ich ja auch alle einzelnen libs in extraordner packen 
und nur das verwendete includen.

Was ist eleganter bzw. praktischer?
(Weiß ja nicht welche tricks noch alles dazu kommen :-) )

Grüße,
Tom

[Tom S. (tomsawer)]

Dabei müsste ich immer eine neuen "AVR static library" erzeugen und kann 
nicht einfach nur den lib-Ordner angeben, da dieser ja sonst nicht weiß 
wo er die avr-libc findet ( z.b. #include <avr/io.h> ) Korrekt?

Das würde dann ne lange lisste an lib_X, lib_Y in meinem Workspace 
ergeben -> unschön.

Wie macht Ihr das?

[Tom S. (tomsawer)]

Ok Habs jetzt halbwegs übersichtlich hinbekommen.

Alle libs liegen in eigenem Ordner und die in einem lib Ordner.

Nun muss ich zwar jede lib einzeln linken, aber der Aufwand geht schon 
i.o.
Dachte man kann sichs einfacher machen.

Wenn jemand nen hilfreichen link hat wo das mit dem ganzen includen und 
linken kurz und knapp erklärt wird, ich Freu mich!

mir fehlt leider auch das nötige Vokabular zum Suchen im Netz da ich 
autoditaktischer einzelkämpfer bin :-/

[Karl H. (kbuchegg)]

Vorsicht:

Das was wir hier im Forum des öfteren eine Lib (Library) nennen, ist in 
Wirklichkeit keine. Daher auch der dich verblüffende Unterschied zur 
avr-libc.

die avr-libc ist bereits vorkompiliert und mit einem Tool, dem sog. 
Librarien in eine echte Library verpackt worden. Der Linker holt sich 
dann aus dieser Library die Teile, die er benötigt um das Programm 
fertig zu stellen.

Das ist aber etwas ganz anderes, als eine Sammlung von Source Code Files 
auf einem Directory. Die kann man zwar auch im weitesten Sinne eine 
Library nennen, eine Source Code Library, aber eigentlich versteht man 
im Build-Prozess unter einer Library etwas anderes - eine Sammlung von 
vorkompilierten Dingen, die mit dem Librarien zu einer Object Code 
Library zusammengefasst wurden.

[Kan a. (Firma: Basta) (kanasta)]

Trotzdem gibts zur Library immer Include-Dateien,
in der (Funktions-)Definitionen festgehalten sind.

Ich glaube, Karl Heinz will ausdrücken, dass es
vorkompilierte als auch quelloffene Bibliotheken
gibt.

[Karl H. (kbuchegg)]

Kan asta schrieb:
> Trotzdem gibts zur Library immer Include-Dateien,
> in der (Funktions-)Definitionen festgehalten sind.

Daran hatte ich in der Tat nicht mehr gedacht.
Danke für die Ergänzung.

[Tom S. (tomsawer)]

Danke für die Infos! Muss es einfach verstehen bis in die Wurzel :-O

Für mich war das immer Quellcode, der irgendeine spezifische Funktion 
hat, meistens kleine Hardwaretreiber.

Das Projekt muss sich selbst noch als relativen Inklude-Pfad hinzufügen, 
damit dann lcd.h . . . lcd_cfg.h "sehen" kann.

Das habe ich mitlerweile glücklich am laufen :-):

Projekt
-----------------------
main.c:
    #include <lcd.h>
    ....
    ....

lcd_cfg.h:
    #define LCD_PORT  PORTD
    ....
    .....

library
-----------------------
lcd.h
    #include <lcd_cfg.h>

lcd.c
    mach was mit LCD_PORT

Da ich aus der lcd.h die Projektspezifische lcd_cfg.h inkludiere und 
diese fundamentale Infomationen enthält, kann ich den lcd-Quellcode ja 
nicht vorkompilieren. Richtig?

Wenns keine library ist, was ists dann? Keine Codeschnippsel mehr, oder?