BIT manipulation

I have been programming in Pascal (Mikro Pascal) and Assembler for some time, and have decided to have a crack at C using XC8 in the hope of generating tighter more compact memory saving code than Pascal, and not as time consuming as Assembler.
The problem I have uncounted and hoping for some help/direction, is in bit setting and clearing.
ie: In Pascal "bitname.0 := 1;" will set bit zero of bitname, and "bitname.0 := 0;"  would clear the bit.
Reading a bit would be eg: "if bitname.0 = 1 then etc etc etc...."
I've have read explanations in various C publications that seem to indicate one has to AND or OR bits to perform the operation of setting and clearing bits.
I have attempted manipulating bits of a struct and integer without success either. (bit.bit0 = 1  or bit[0] = 1 ??)
Hope someone can point me in the correct direction and perhaps tell me where I am going wrong?
Many thanks. 
 

Hi,
When using XC8 compiler,  there is a file available for each type of PIC microcontroller,
with name for each register, field and bit, named as documented in the datasheet for the device,
 
When PIC microcontroller type have been selected in MPLAB,
then the 'device support file' is made available in your source code file by typing:

#include  <xc.h>    

in the source file.
 
The "bit field" structs   have this form:  REGISTERbits.BIT   or REGISTERbits.FIELD, where you replace the uppercase names with actual register and bit names, as documented in the datasheet.
Example:

    LATC = 0;                // Clear all bits of this register to zero. 
    LATCbits.LATC6 = 1;      // Set a single bit.
    ANSELC = 0;              // Enable Digital Inputs for all pins on port C, only for microcontrollers that have Analog features on this port.
    TRISCbits.TRISC3 = 1;    // Set tristate control bit to input for pin RC3.
    TRISCbits.TRISC4 = 1;    // Set tristate control bit to input for pin RC4.
    TRISCbits.TRISC6 = 0;    // Clear tristate control bit for output on pin RC6.   

 
There are bit macro definitions that may be used in mask and shift operations:

    while ((SSPCON2 & ( _SSPCON2_SEN_MASK | _SSPCON2_RSEN_MASK | _SSPCON2_PEN_MASK | _SSPCON2_RCEN_MASK | _SSPCON2_ACKEN_MASK))
           || (SSPSTAT &  _SSPSTAT_R_nW_MASK))
        NOP;   

 
There also are shorthand macro definitions available for many register bits.
Some SFR bits are placed in different registers in different device families.
It may be easier to type:

    SSP1IF = 0;    // Clear interrupt flag
    SSP1IE = 1;    // Enable interrupt
    BCL1IF = 0;
    BCL1IE = 1;   

 
Instead of: 

#if defined  _16F1718
    PIR1bits.SSP1IF = 0;    // Clear interrupt flag
    PIE1bits.SSP1IE = 1;    // Enable interrupt
    PIR2bits.BCL1IF = 0; 
    PIE2bits.BCL1IE = 1;
#elif defined  _16F18875   // Different device have different register layout:
    PIR3bits.SSP1IF = 0;    // Clear interrupt flag
    PIE3bits.SSP1IE = 1;    // Enable interrupt
    PIR3bits.BCL1IF = 0; 
    PIE3bits.BCL1IE = 1;
#endif    

 
If such symbolic register and field names are used in a systematic way,
and then use the code for a different device type,
then the compiler will either adapt to differences if it can,
or tell where attention is needed.
 
    Mysil

lewjoubert
hope of generating tighter more compact memory saving code than Pascal, 

As well as what other have said, don't forget to enable optimization :)
 
To expand in the union idea, I use a typedef:
 

typedef union {
 struct {
 unsigned fast_led:1;
 unsigned slow_led:1;
 unsigned can_stretch:1;
 unsigned :1;
 unsigned slot_timer:1;
 unsigned send_current:1;
 unsigned send_voltage:1;
 unsigned :1;
 } ;
 uint8_t byte;
} timer_flags_t;
extern volatile timer_flags_t timer_flags;

 
then

timer_flags.byte = 0; // clear all bits
timer_flags.fast_led = 1; // set a bit

 
Also you should prefer

timer_flags.fast_led ^= 1; // toggle a bit

 
over

t imer_flags.fast_led = ~timer_flags.fast_led; // toggle a bit

 
Look at the disassembly to see why!

NorthGuy
You can also use logic operations.

Turn them into macros:

#define bitset(var, pos)  (var |= (1uL << pos))
#define bitclr(var, pos)  (var &= (~(1uL << pos)))
#define bitflip(var, pos) (var ^= (1uL << pos))