"expected ')' before '*' token" -- Was ist da los?

[Robert S. (razer)]

Hallo an alle,

Ich versuche schon seit ein paar Stunden meinen Source Code zu 
kompilieren :(

Jedoch bekomme ich immer diese Fehlermeldung "expected ')' before '*' 
token".

In der parser.c ist die Funktion parser(CANMessage *msg) implementiert. 
Im zugehörigen Header der Prototyp. Die Struktur CANMessage ist in der 
Datei can.h definiert.

Jedoch will das nicht klappen :(

parser.h:

 #ifndef PARSER_H
 #define PARSER_H
 
 #include "boot.h"
 #include "can.h"

 #define GET_PAGE_SETTINGS  0x00
 #define GET_FLASH_DATA    0x01
 #define FLASH_PAGE      0x02
 #define START_APP      0x03
 
  void parser(CANMessage *msg);
    
  void (*jump_to_app)( void ) ;
  
 #endif

parser.c

 #include "parser.h"
 
typedef struct Flashpage
{
  unsigned char buf[150];
  unsigned char pageNr;
  unsigned int pagesize;
  unsigned char *ptr;
} sFlashPage;

sFlashPage flashPage;

 void (*jump_to_app)( void ) = 0x0000;
 
 void parser(CANMessage *msg)
 {
  switch(msg->data[0])
  {
    case GET_PAGE_SETTINGS:
      flashPage.pagesize = (unsigned int) msg->data[1] << 8;
      flashPage.pagesize |= msg->data[2];
      flashPage.pageNr = msg->data[3];
      flashPage.ptr = &flashPage.buf[0];
    break;
    case GET_FLASH_DATA:
      for(unsigned char i = 1; i < 7; i++)
        *(flashPage.ptr++) = msg->data[i];
    break;
    case FLASH_PAGE:
      boot_program_page (flashPage.pageNr, flashPage.buf);
    break;
    case START_APP:
      jump_to_app();
    break;
    
  }
}

can.h

#ifndef CAN_H
 #define CAN_H
 
 #include "mcp2515.h"
 #include "parser.h"
 #include "spi.h"
 #include "avr/interrupt.h"
 
 #define TX_RTS_DDR    DDRB
 #define TX_RTS_PORT  PORTB
 #define TX_RTS0    PB0    
 #define TX_RTS1    PB1
 #define TX_RTS2    PB3
 
 #define setOutput(ddr, pin)  (ddr |= (1 << pin))
 #define setInput(ddr, pin)    (ddr &= ~(1 << pin))
 #define setPin(port, pin)    (port |= (1 << pin))
 #define clearPin(port, pin)  (port &= ~(1 << pin))
 
 #define sendBuffer0()      setPin(TX_RTS_PORT, TX_RTS0)
 #define sendBuffer1()      setPin(TX_RTS_PORT, TX_RTS1)
 #define sendBuffer2()      setPin(TX_RTS_PORT, TX_RTS2)
 
 typedef struct sCANMessage
{
    uint16_t  id;
    uint8_t   rtr;
    uint8_t   length;
    uint8_t   data[8];
} CANMessage;
 #endif

Weiß jemand was los ist?
Ich hoffe es aknn jemand helfen.

Gruß Robert

[Chris (Gast)]

Ist das die einzige Fehlermeldung? Falls ja, auf welche Zeile bezieht 
die sich?

[Robert S. (razer)]

Diese Fehlermeldung bezieht sich auf die Zeile, in der die Funktion 
parser() in parser.h deklariert wird.

Es gibt noch eine 2. und zwar beim Aufruf der Funktion Parser in can.c

Gruß Robert

[Uhu U. (uhu)]

Die Fehlermeldung bedeutet, daß bei

   void parser(CANMessage *msg);

der Typ CANMessage nicht bekannt ist.

Setz mal direkt vor #include "can.h" folgenden Text.

   #ifdef CAN_H
   #error CAN_H ist definiert
   #endif

Wenn der Compiler den Text nach #error als Fehlermeldung anzeigt, dann 
ist CAN_H bereits definiert und deswegen wird der Inhalt deines Headers 
can.h nicht ausgewertet.

[Robert S. (razer)]

Ich habs jetzt

 #ifndef PARSER_H
 #define PARSER_H
 
 #include "boot.h"
 
 #ifdef CAN_H
 #error CAN_H ist definiert
 #endif
 
//#include "can.h"
 
  void parser(CANMessage *msg);
    
  void (*jump_to_app)( void ) ;
  
 #endif

Ist #include "can.h" auskommentiert, bekomm ich die gleich Fehermeldung. 
Wenn es drinnen ist, bekomm ich diese Fehlermeldungen:

                 from can.c:20:
parser.h:26:3: error: #error CAN_H ist definiert
In file included from can.h:24,
                 from can.c:20:
parser.h:31: error: expected ')' before '*' token
can.c: In function '__vector_1':
can.c:205: warning: implicit declaration of function 'parser'

Hat leider auch nicht geklappt.

Gruß Robert

[Uhu U. (uhu)]

Doch, hat prima geklappt!

Das einzige, was du jetzt noch machen mußt, ist, für dein privates CAN_H 
ein anderes Symbol auswählen - CAN_H wird vom Compiler bereits 
verwendet! (Und natürlich das #ifdef... Zeug wieder rauslöschen.)

Generell ist es keine gute Idee, Symbole nach diesem Muster selbst zu 
definierten - die sind nämlich für den Compiler reserviert.

Mach dich mal schlau, was #ifdef und #error machen.

[Robert S. (razer)]

Uhu Uhuhu wrote:
> Doch, hat prima geklappt!

error: #error CAN_H ist definiert: Dachte wegen dem #error, da das auch 
mit ausgegeben wurde hat nicht geklappt...


> Das einzige, was du jetzt noch machen mußt, ist, die für dein privates
> CAN_H ein anderes Symbol auswählen - CAN_H wird vom Compiler bereits
> verwendet! (Und natürlich das #ifdef... Zeug wieder rauslöschen.)

Es wird doh nur meine eigene CAN_H verwendet. Mehrfach einbindungen in 
verschiedenen C Files sind ja möglich.

Muss ich demnach CAN_H in zB AVR_CAN_H umbenennen?

Gruß Robert

[Uhu U. (uhu)]

Und warum ist CAN_H dann definiert? Wenn du es bis zu dem #ifdef CAN_H 
nicht selbst gemacht hast, dann wird es in boot.h oder einer dort 
includierten Datei gemacht, oder per -D-Option über den Makefile.

AVR_CAN_H ist OK.

Es könnte sein, daß der gcc kein #error kann - lies mal nach. Aber auch 
wenn er es nicht kann, hat der Trick funktioniert.

[Robert S. (razer)]

Wenn ich alles in AVR_CAN_H umbenenne hab ich aber das gleiche Problem.

[Uhu U. (uhu)]

> //#include "can.h"

Ist das wieder entkommentiert?

Was passiert, wenn du

   #ifndef CAN_H
   #define CAN_H

und

   #endif

in can.h auskommentierst?

[Robert S. (razer)]

Uhu Uhuhu wrote:
>> //#include "can.h"
>
> Ist das wieder entkommentiert?

Ja

> Was passiert, wenn du
>
>    #ifndef CAN_H
>    #define CAN_H
>
> und
>
>    #endif
>
> in can.h auskommentierst?

Dann bekomm ich die Fehlermeldung:

In file included from avr_can.c:20:
avr_can.h:44: error: redefinition of 'struct sCANMessage'
avr_can.h:49: error: redefinition of typedef 'CANMessage'
avr_can.h:49: error: previous declaration of 'CANMessage' was here

[Uhu U. (uhu)]

Aha, interessant.

Dann ändere mal den Namen deiner sCANMessage und CANMessage.

Offensichtlich wird doch schon irgendwo CAN-Zeug reingezogen...

Wie sieht denn dein Makefile aus?

[Robert S. (razer)]

Ich hab das ganze in sCANMsg und CANMsg geändert, doch der gleiche 
Effekt...

Edit:
Mein Makefile:

# Hey Emacs, this is a -*- makefile -*-
#
# WinAVR makefile written by Eric B. Weddington, Jörg Wunsch, et al.
# Released to the Public Domain
# Please read the make user manual!
#
# Additional material for this makefile was submitted by:
#  Tim Henigan
#  Peter Fleury
#  Reiner Patommel
#  Sander Pool
#  Frederik Rouleau
#  Markus Pfaff
#
# On command line:
#
# make all = Make software.
#
# make clean = Clean out built project files.
#
# make coff = Convert ELF to AVR COFF (for use with AVR Studio 3.x or VMLAB).
#
# make extcoff = Convert ELF to AVR Extended COFF (for use with AVR Studio
#                4.07 or greater).
#
# make program = Download the hex file to the device, using avrdude.  Please
#                customize the avrdude settings below first!
#
# make filename.s = Just compile filename.c into the assembler code only
#
# To rebuild project do "make clean" then "make all".
#

# mth 2004/09 
# Differences from WinAVR 20040720 sample:
# - DEPFLAGS according to Eric Weddingtion's fix (avrfreaks/gcc-forum)
# - F_OSC Define in CFLAGS and AFLAGS


# MCU name
MCU = atmega32

# Main Oscillator Frequency
# This is only used to define F_OSC in all assembler and c-sources.
F_OSC = 16000000 

# Output format. (can be srec, ihex, binary)
FORMAT = ihex

# Target file name (without extension).
TARGET = main


# List C source files here. (C dependencies are automatically generated.)
SRC = $(TARGET).c spi.c mcp2515.c avr_can.c boot.c parser.c


# List Assembler source files here.
# Make them always end in a capital .S.  Files ending in a lowercase .s
# will not be considered source files but generated files (assembler
# output from the compiler), and will be deleted upon "make clean"!
# Even though the DOS/Win* filesystem matches both .s and .S the same,
# it will preserve the spelling of the filenames, and gcc itself does
# care about how the name is spelled on its command-line.
ASRC = 



# Optimization level, can be [0, 1, 2, 3, s]. 
# 0 = turn off optimization. s = optimize for size.
# (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
OPT = s

# Debugging format.
# Native formats for AVR-GCC's -g are stabs [default], or dwarf-2.
# AVR (extended) COFF requires stabs, plus an avr-objcopy run.
#DEBUG = stabs
#DEBUG = dwarf-2

# List any extra directories to look for include files here.
#     Each directory must be seperated by a space.
EXTRAINCDIRS = 


# Compiler flag to set the C Standard level.
# c89   - "ANSI" C
# gnu89 - c89 plus GCC extensions
# c99   - ISO C99 standard (not yet fully implemented)
# gnu99 - c99 plus GCC extensions
CSTANDARD = -std=gnu99

# Place -D or -U options here
CDEFS =

# Place -I options here
CINCS =


# Compiler flags.
#  -g*:          generate debugging information
#  -O*:          optimization level
#  -f...:        tuning, see GCC manual and avr-libc documentation
#  -Wall...:     warning level
#  -Wa,...:      tell GCC to pass this to the assembler.
#    -adhlns...: create assembler listing
CFLAGS = -g$(DEBUG)
CFLAGS += $(CDEFS) $(CINCS)
CFLAGS += -O$(OPT)
CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
CFLAGS += -Wall -Wstrict-prototypes
#CFLAGS += -Wall
CFLAGS += -Wa,-adhlns=$(<:.c=.lst)
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
CFLAGS += $(CSTANDARD)
CFLAGS += -DF_OSC=$(F_OSC)



# Assembler flags.
#  -Wa,...:   tell GCC to pass this to the assembler.
#  -ahlms:    create listing
#  -gstabs:   have the assembler create line number information; note that
#             for use in COFF files, additional information about filenames
#             and function names needs to be present in the assembler source
#             files -- see avr-libc docs [FIXME: not yet described there]
ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs 
ASFLAGS += -DF_OSC=$(F_OSC)


#Additional libraries.

# Minimalistic printf version
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min

# Floating point printf version (requires MATH_LIB = -lm below)
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt

PRINTF_LIB = 

# Minimalistic scanf version
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min

# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt

SCANF_LIB = 

MATH_LIB = -lm

# External memory options

# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# used for variables (.data/.bss) and heap (malloc()).
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff

# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# only used for heap (malloc()).
#EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x80ffff

EXTMEMOPTS =

# Linker flags.
#  -Wl,...:     tell GCC to pass this to linker.
#    -Map:      create map file
#    --cref:    add cross reference to  map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)




# Programming support using avrdude. Settings and variables.

# Programming hardware: alf avr910 avrisp bascom bsd 
# dt006 pavr picoweb pony-stk200 sp12 stk200 stk500
#
# Type: avrdude -c ?
# to get a full listing.
#
AVRDUDE_PROGRAMMER = stk500

# com1 = serial port. Use lpt1 to connect to parallel port.
AVRDUDE_PORT = com2    # programmer connected to serial device

AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep


# Uncomment the following if you want avrdude's erase cycle counter.
# Note that this counter needs to be initialized first using -Yn,
# see avrdude manual.
#AVRDUDE_ERASE_COUNTER = -y

# Uncomment the following if you do /not/ wish a verification to be
# performed after programming the device.
#AVRDUDE_NO_VERIFY = -V

# Increase verbosity level.  Please use this when submitting bug
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> 
# to submit bug reports.
#AVRDUDE_VERBOSE = -v -v

AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)



# ---------------------------------------------------------------------------

# Define directories, if needed.
DIRAVR = c:/winavr
DIRAVRBIN = $(DIRAVR)/bin
DIRAVRUTILS = $(DIRAVR)/utils/bin
DIRINC = .
DIRLIB = $(DIRAVR)/avr/lib


# Define programs and commands.
SHELL = sh
CC = avr-gcc
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
SIZE = avr-size
NM = avr-nm
AVRDUDE = avrdude
REMOVE = rm -f
COPY = cp




# Define Messages
# English
MSG_ERRORS_NONE = Errors: none
MSG_BEGIN = -------- begin --------
MSG_END = --------  end  --------
MSG_SIZE_BEFORE = Size before: 
MSG_SIZE_AFTER = Size after:
MSG_COFF = Converting to AVR COFF:
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
MSG_FLASH = Creating load file for Flash:
MSG_EEPROM = Creating load file for EEPROM:
MSG_EXTENDED_LISTING = Creating Extended Listing:
MSG_SYMBOL_TABLE = Creating Symbol Table:
MSG_LINKING = Linking:
MSG_COMPILING = Compiling:
MSG_ASSEMBLING = Assembling:
MSG_CLEANING = Cleaning project:




# Define all object files.
OBJ = $(SRC:.c=.o) $(ASRC:.S=.o) 

# Define all listing files.
LST = $(ASRC:.S=.lst) $(SRC:.c=.lst)


# Compiler flags to generate dependency files.
### GENDEPFLAGS = -Wp,-M,-MP,-MT,$(*F).o,-MF,.dep/$(@F).d
GENDEPFLAGS = -MD -MP -MF .dep/$(@F).d

# Combine all necessary flags and optional flags.
# Add target processor to flags.
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)





# Default target.
all: begin gccversion sizebefore build sizeafter finished end

build: elf hex eep lss sym 

elf: $(TARGET).elf
hex: $(TARGET).hex
eep: $(TARGET).eep
lss: $(TARGET).lss 
sym: $(TARGET).sym



# Eye candy.
# AVR Studio 3.x does not check make's exit code but relies on
# the following magic strings to be generated by the compile job.
begin:
  @echo
  @echo $(MSG_BEGIN)

finished:
  @echo $(MSG_ERRORS_NONE)

end:
  @echo $(MSG_END)
  @echo


# Display size of file.
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
ELFSIZE = $(SIZE) $(TARGET).elf
sizebefore:
  @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); echo; fi

sizeafter:
  @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); echo; fi



# Display compiler version information.
gccversion : 
  @$(CC) --version



# Program the device.  
program: $(TARGET).hex $(TARGET).eep
  $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)




# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
COFFCONVERT=$(OBJCOPY) --debugging \
--change-section-address .data-0x800000 \
--change-section-address .bss-0x800000 \
--change-section-address .noinit-0x800000 \
--change-section-address .eeprom-0x810000 


coff: $(TARGET).elf
  @echo
  @echo $(MSG_COFF) $(TARGET).cof
  $(COFFCONVERT) -O coff-avr $< $(TARGET).cof


extcoff: $(TARGET).elf
  @echo
  @echo $(MSG_EXTENDED_COFF) $(TARGET).cof
  $(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof



# Create final output files (.hex, .eep) from ELF output file.
%.hex: %.elf
  @echo
  @echo $(MSG_FLASH) $@
  $(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@
#  mv main.hex main.bin

%.eep: %.elf
  @echo
  @echo $(MSG_EEPROM) $@
  -$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
  --change-section-lma .eeprom=0 -O $(FORMAT) $< $@

# Create extended listing file from ELF output file.
%.lss: %.elf
  @echo
  @echo $(MSG_EXTENDED_LISTING) $@
  $(OBJDUMP) -h -S $< > $@

# Create a symbol table from ELF output file.
%.sym: %.elf
  @echo
  @echo $(MSG_SYMBOL_TABLE) $@
  $(NM) -n $< > $@



# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
  @echo
  @echo $(MSG_LINKING) $@
  $(CC) $(ALL_CFLAGS) $(OBJ) --output $@ $(LDFLAGS)


# Compile: create object files from C source files.
%.o : %.c
  @echo
  @echo $(MSG_COMPILING) $<
  $(CC) -c $(ALL_CFLAGS) $< -o $@ 


# Compile: create assembler files from C source files.
%.s : %.c
  $(CC) -S $(ALL_CFLAGS) $< -o $@


# Assemble: create object files from assembler source files.
%.o : %.S
  @echo
  @echo $(MSG_ASSEMBLING) $<
  $(CC) -c $(ALL_ASFLAGS) $< -o $@



# Target: clean project.
clean: begin clean_list finished end
  rm main.bin

clean_list :
  @echo
  @echo $(MSG_CLEANING)
  $(REMOVE) $(TARGET).hex
  $(REMOVE) $(TARGET).eep
  $(REMOVE) $(TARGET).obj
  $(REMOVE) $(TARGET).cof
  $(REMOVE) $(TARGET).elf
  $(REMOVE) $(TARGET).map
  $(REMOVE) $(TARGET).obj
  $(REMOVE) $(TARGET).a90
  $(REMOVE) $(TARGET).sym
  $(REMOVE) $(TARGET).lnk
  $(REMOVE) $(TARGET).lss
  $(REMOVE) $(OBJ)
  $(REMOVE) $(LST)
  $(REMOVE) $(SRC:.c=.s)
  $(REMOVE) $(SRC:.c=.d)
  $(REMOVE) .dep/*



# Include the dependency files.
-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)


# Listing of phony targets.
.PHONY : all begin finish end sizebefore sizeafter gccversion \
build elf hex eep lss sym coff extcoff \
clean clean_list program

[Uhu U. (uhu)]

Wie sieht denn dein Makefile aus?

[Robert S. (razer)]

Makefile hab ich gepostet

[Uhu U. (uhu)]

> SRC = $(TARGET).c spi.c mcp2515.c avr_can.c boot.c parser.c

Na da ist doch noch ein ganzer Sack weiterer Quellfiles im Spiel und 
deine neuen Fehlermeldungen kommen aus avr_can.c, nicht aus parser.c

Jetzt mußt du dir avr_can.c näher ansehen.

[Robert S. (razer)]

Das is die ursprüngliche can.h/can.c die ich umbenannt habe

[Uhu U. (uhu)]

Mir scheint, wir müssen das alles nochmal genau durchgehen.

Fehlermeldungen wie

   "expected ')' before '*' token"

deuten an der Stelle, an der sie bei dir auftrat, auf einen 
undefinierten Datentyp. (Die merkwürdige Art, solche Fehler zu melden, 
ist typisch für bottom-up-Parser, wie sie z.B. in C-Compilern eingesetzt 
werden.)

Das #ifdef CAN_H vor #include "can.h" war erfüllt, also muß irgendwie 
das CAN_H definiert gewesen sein.

[Andreas K. (a-k)]

Wahrscheinlich wird can.h zweimal reingezogen, daher der Spuk mit CAN_H. 
Das ist aber nicht das Problem.

Was manchmal hilft:
  avr-gcc -E quellfile.c
um sich anzusehen, ob der Präprozessor irgendwelchen Unfug gestiftet 
hat.

[Robert S. (razer)]

Also die can.h ist in mehreren C Files inkludiert.

Also die #error CAN_H ist definiert kommt nur wenn darunter die can.h 
inkludiert wird. Andernfalls kommt nur die expected ')' before '*' token 
Fehlermeldung.

[Robert S. (razer)]

Also das sind die Ausgaben (nur die includes)

typedef uint64_t uint_least64_t;
# 213 "c:/winavr-20070525/bin/../avr/include/stdint.h" 3
typedef int8_t int_fast8_t;




typedef uint8_t uint_fast8_t;




typedef int16_t int_fast16_t;




typedef uint16_t uint_fast16_t;




typedef int32_t int_fast32_t;




typedef uint32_t uint_fast32_t;







typedef int64_t int_fast64_t;






typedef uint64_t uint_fast64_t;
# 273 "c:/winavr-20070525/bin/../avr/include/stdint.h" 3
typedef int64_t intmax_t;




typedef uint64_t uintmax_t;
# 38 "c:/winavr-20070525/bin/../avr/include/inttypes.h" 2 3
# 77 "c:/winavr-20070525/bin/../avr/include/inttypes.h" 3
typedef int32_t int_farptr_t;



typedef uint32_t uint_farptr_t;
# 127 "c:/winavr-20070525/bin/../avr/include/avr/sfr_defs.h" 2 3
# 88 "c:/winavr-20070525/bin/../avr/include/avr/io.h" 2 3
In file included from mcp2515.h:23,
                 from can.h:23,
                 from can.c:20:
c:/winavr-20070525/bin/../avr/include/avr/io.h:356:6: warning: #warning "device
type not defined"
# 360 "c:/winavr-20070525/bin/../avr/include/avr/io.h" 3
# 1 "c:/winavr-20070525/bin/../avr/include/avr/portpins.h" 1 3
# 361 "c:/winavr-20070525/bin/../avr/include/avr/io.h" 2 3
# 370 "c:/winavr-20070525/bin/../avr/include/avr/io.h" 3
# 1 "c:/winavr-20070525/bin/../avr/include/avr/version.h" 1 3
# 371 "c:/winavr-20070525/bin/../avr/include/avr/io.h" 2 3
# 24 "mcp2515.h" 2
# 1 "spi.h" 1
# 28 "spi.h"
 void spiMasterInit(unsigned char pre);

 unsigned char spiWrite(unsigned char data);

 unsigned char spiRead(void);
# 25 "mcp2515.h" 2
# 33 "mcp2515.h"
 unsigned char mcp2515_readRegister(unsigned char adress);

 void mcp2515_modifyRegister(unsigned char adress, unsigned char bitmask, unsign
ed char data);

  void mcp2515Init(void);
# 24 "can.h" 2
# 1 "parser.h" 1
In file included from can.h:24,
                 from can.c:20:
parser.h:24:5: error: #error CAN_H ist definiert
# 28 "parser.h"
# 1 "boot.h" 1
# 23 "boot.h"
     void boot_program_page (uint32_t page, uint8_t *buf);
# 29 "parser.h" 2

  void parser(CANMsg *msg);

  void (*jump_to_app)( void ) ;
# 25 "can.h" 2

# 1 "c:/winavr-20070525/bin/../avr/include/avr/interrupt.h" 1 3
# 27 "can.h" 2
# 43 "can.h"
 typedef struct sCANMsg
{
    uint16_t id;
    uint8_t rtr;
    uint8_t length;
    uint8_t data[8];
} CANMsg;
# 21 "can.c" 2






typedef struct Flashpage
{
 unsigned char buf[150];
 unsigned char pageNr;
 unsigned int pagesize;
 unsigned char *ptr;
} sFlashPage;

sFlashPage flashPage;

Ich hoff das hilft,

[Uhu U. (uhu)]

void parser(CANMsg *msg);

steht vor der Definition von CANMsg - das ist alles...

# 29 "parser.h" 2

  void parser(CANMsg *msg);

  void (*jump_to_app)( void ) ;
# 25 "can.h" 2

# 1 "c:/winavr-20070525/bin/../avr/include/avr/interrupt.h" 1 3
# 27 "can.h" 2
# 43 "can.h"
 typedef struct sCANMsg
{
    uint16_t id;
    uint8_t rtr;
    uint8_t length;
    uint8_t data[8];
} CANMsg;
# 21 "can.c" 2

[Andreas K. (a-k)]

Wirf aus can.h das #include "parser.h" raus.

[Robert S. (razer)]

Uhu Uhuhu wrote:
> void parser(CANMsg *msg);
>
> steht vor der Definition von CANMsg - das ist alles...

Andreas Kaiser wrote:
>Und was kann ich dagegen machen?

Hilft nicht

[Uhu U. (uhu)]

> parser.c
>
> #include "parser.h"

----------

> parser.h:
>
> #ifndef PARSER_H
> #define PARSER_H
>
> #include "boot.h"
> #include "can.h"

-----------

> can.h
>
>  #ifndef CAN_H
>   #define CAN_H
>
>  #include "mcp2515.h"
>  #include "parser.h"

Also:

parser.c zieht parser.h rein
   parser.h zieht can.h rein
      can.h zieht parser.h rein

Damit schaffst du es, daß der Compiler das

   void parser(CANMessage *msg);

vor der Definition von CANMessage sieht.

[Robert S. (razer)]

Ok, das ist klar.

Doch was kann ich dagegen machen?

Gruß Robert

[Uhu U. (uhu)]

Andreas Kaiser wrote:
> Wirf aus can.h das #include "parser.h" raus.

Genau so.

[Robert S. (razer)]

Geht leider immer noch nicht.

Compiling: can.c
avr-gcc -c -mmcu=atmega32 -I. -g   -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=can.lst  -std=gnu99 -DF_OSC=16000000  -MD -MP -MF .dep/can.o.d can.c -o can.o 
can.c: In function '__vector_1':
can.c:164: warning: implicit declaration of function 'parser'

Compiling: parser.c
avr-gcc -c -mmcu=atmega32 -I. -g   -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=parser.lst  -std=gnu99 -DF_OSC=16000000  -MD -MP -MF .dep/parser.o.d parser.c -o parser.o 
parser.c:43: error: expected ')' before '*' token
make.exe: *** [parser.o] Error 1

Gruß Robert

[Uhu U. (uhu)]

Du hast drei Möglichkeiten:

1. Deine #include-Folgen so zu konstruieren, daß keine Definitionen 
benutzt werden, bevor der Compiler sie gesehen hat

2. Du schreibst die *.c und *.h so um, daß kein Header einen anderen von 
deinen eigenen Header includiert

3. Du schreibst

   void parser(struct sCANMessage *msg);

und verzichtest auf den Effekt des typedef.

Ich würde die zweite Möglichkeit nehmen, weil man sich damit bei 
größeren Projekten diese Art unübersichtlicher Headerprobleme vom Leib 
halten kann.

[Robert S. (razer)]

Danke jetzt gehts :)