Community Company Search Contact

modules_main.c from CQual at Krugle

Show modules_main.c syntax highlighted

typedef struct {
        volatile unsigned int lock;
} spinlock_t;

typedef long off_t;
typedef unsigned char cc_t;
typedef unsigned int tcflag_t;
typedef unsigned short mode_t;
typedef unsigned int size_t;
typedef int pm_request_t;
typedef int pm_dev_t;
typedef long long loff_t;
typedef unsigned long ino_t;
typedef unsigned short kdev_t;
typedef int ssize_t;
typedef unsigned int u32;
typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);
typedef struct { volatile int counter; } atomic_t;

extern int init_module(void);
extern void cleanup_module(void);

struct tty_struct;
struct tty_struct;
struct file;
struct inode;
struct poll_table_struct;
struct dentry;
struct iovec;
struct page;
struct pt_regs;
struct vm_area_struct;
struct file_lock;
struct pci_dev;
struct pm_dev;
struct sk_buff;
struct hh_cache;
struct ifmap;
struct ifreq;
struct neigh_parms;
struct dst_entry;
struct neighbour;
struct super_block;
struct socket;

typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data);

struct list_head {
        struct list_head *next, *prev;
};

struct timer_list {
        struct list_head list;
        unsigned long expires;
        unsigned long data;
        void (*function)(unsigned long);
};

struct file_system_type {
        const char *name;
        int fs_flags;
        struct super_block *(*read_super) (struct super_block *, void *, int);
        struct module *owner;
        struct vfsmount *kern_mnt;
        struct file_system_type * next;
};

struct file_operations {
        struct module *owner;
        loff_t (*llseek) (struct file *, loff_t, int);
        ssize_t (*read) (struct file *, char *, size_t, loff_t *);
        ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
        int (*readdir) (struct file *, void *, filldir_t);
        unsigned int (*poll) (struct file *, struct poll_table_struct *);
        int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
        int (*mmap) (struct file *, struct vm_area_struct *);
        int (*open) (struct inode *, struct file *);
        int (*flush) (struct file *);
        int (*release) (struct inode *, struct file *);
        int (*fsync) (struct file *, struct dentry *, int datasync);
        int (*fasync) (int, struct file *, int);
        int (*lock) (struct file *, int, struct file_lock *);
        ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
        ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
};

struct block_device_operations {
        int (*open) (struct inode *, struct file *);
        int (*release) (struct inode *, struct file *);
        int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
        int (*check_media_change) (kdev_t);
        int (*revalidate) (kdev_t);
};

typedef struct devfs_entry * devfs_handle_t;
struct gendisk {
        int major;
        const char *major_name;
        int minor_shift;
        int max_p;
        struct hd_struct *part;
        int *sizes;
        int nr_real;
        void *real_devices;
        struct gendisk *next;
        struct block_device_operations *fops;
        devfs_handle_t *de_arr;
        char *flags;
};

struct miscdevice
{
        int minor;
        const char *name;
        struct file_operations *fops;
        struct miscdevice * next, * prev;
        devfs_handle_t devfs_handle;
};

struct pci_driver {
        struct list_head node;
        char *name;
        const struct pci_device_id *id_table;
        int (*probe) (struct pci_dev *dev, const struct pci_device_id *id);
        void (*remove) (struct pci_dev *dev);
        int (*save_state) (struct pci_dev *dev, u32 state);
        int (*suspend)(struct pci_dev *dev, u32 state);
        int (*resume) (struct pci_dev *dev);
        int (*enable_wake) (struct pci_dev *dev, u32 state, int enable);
};

struct net_device
{
        char name[16];
        unsigned long rmem_end;
        unsigned long rmem_start;
        unsigned long mem_end;
        unsigned long mem_start;
        unsigned long base_addr;
        unsigned int irq;
        unsigned char if_port;
        unsigned char dma;
        unsigned long state;
        struct net_device *next;
        int (*init)(struct net_device *dev);
        struct net_device *next_sched;
        int ifindex;
        int iflink;
        struct net_device_stats* (*get_stats)(struct net_device *dev);
        struct iw_statistics* (*get_wireless_stats)(struct net_device *dev);
        unsigned long trans_start;
        unsigned long last_rx;
        unsigned short flags;
        unsigned short gflags;
        unsigned mtu;
        unsigned short type;
        unsigned short hard_header_len;
        void *priv;
        struct net_device *master;
        unsigned char broadcast[8];
        unsigned char dev_addr[8];
        unsigned char addr_len;
        struct dev_mc_list *mc_list;
        int mc_count;
        int promiscuity;
        int allmulti;
        int watchdog_timeo;
        struct timer_list watchdog_timer;
        void *atalk_ptr;
        void *ip_ptr;
        void *dn_ptr;
        void *ip6_ptr;
        void *ec_ptr;
        struct Qdisc *qdisc;
        struct Qdisc *qdisc_sleeping;
        struct Qdisc *qdisc_list;
        struct Qdisc *qdisc_ingress;
        unsigned long tx_queue_len;
        $unlocked spinlock_t xmit_lock;
        int xmit_lock_owner;
        $unlocked spinlock_t queue_lock;
        atomic_t refcnt;
        int deadbeaf;
        int features;
        void (*uninit)(struct net_device *dev);
        void (*destructor)(struct net_device *dev);
        int (*open)(struct net_device *dev);
        int (*stop)(struct net_device *dev);
        int (*hard_start_xmit) (struct sk_buff *skb,
                                                    struct net_device *dev);
        int (*hard_header) (struct sk_buff *skb,
                                                struct net_device *dev,
                                                unsigned short type,
                                                void *daddr,
                                                void *saddr,
                                                unsigned len);
        int (*rebuild_header)(struct sk_buff *skb);
        void (*set_multicast_list)(struct net_device *dev);
        int (*set_mac_address)(struct net_device *dev,
                                                   void *addr);
        int (*do_ioctl)(struct net_device *dev,
                                            struct ifreq *ifr, int cmd);
        int (*set_config)(struct net_device *dev,
                                              struct ifmap *map);
        int (*hard_header_cache)(struct neighbour *neigh,
                                                     struct hh_cache *hh);
        void (*header_cache_update)(struct hh_cache *hh,
                                                       struct net_device *dev,
                                                       unsigned char * haddr);
        int (*change_mtu)(struct net_device *dev, int new_mtu);
        void (*tx_timeout) (struct net_device *dev);
        int (*hard_header_parse)(struct sk_buff *skb,
                                                     unsigned char *haddr);
        int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
        int (*accept_fastpath)(struct net_device *, struct dst_entry*);
        struct module *owner;
        struct net_bridge_port *br_port;
};

struct notifier_block
{
        int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
        struct notifier_block *next;
        int priority;
};

struct packet_type
{
        unsigned short type;
        struct net_device *dev;
        int (*func) (struct sk_buff *, struct net_device *,
                                         struct packet_type *);
        void *data;
        struct packet_type *next;
};

typedef struct ctl_table ctl_table;
typedef int ctl_handler (ctl_table *table, int *name, int nlen,
                         void *oldval, size_t *oldlenp,
                         void *newval, size_t newlen,
                         void **context);
typedef int proc_handler (ctl_table *ctl, int write, struct file * filp,
                          void *buffer, size_t *lenp);
struct ctl_table
{
        int ctl_name;
        const char *procname;
        void *data;
        int maxlen;
        mode_t mode;
        ctl_table *child;
        proc_handler *proc_handler;
        ctl_handler *strategy;
        struct proc_dir_entry *de;
        void *extra1;
        void *extra2;
};

struct net_device_stats
{
        unsigned long rx_packets;
        unsigned long tx_packets;
        unsigned long rx_bytes;
        unsigned long tx_bytes;
        unsigned long rx_errors;
        unsigned long tx_errors;
        unsigned long rx_dropped;
        unsigned long tx_dropped;
        unsigned long multicast;
        unsigned long collisions;
        unsigned long rx_length_errors;
        unsigned long rx_over_errors;
        unsigned long rx_crc_errors;
        unsigned long rx_frame_errors;
        unsigned long rx_fifo_errors;
        unsigned long rx_missed_errors;
        unsigned long tx_aborted_errors;
        unsigned long tx_carrier_errors;
        unsigned long tx_fifo_errors;
        unsigned long tx_heartbeat_errors;
        unsigned long tx_window_errors;
        unsigned long rx_compressed;
        unsigned long tx_compressed;
};

typedef struct wandev_conf wandev_conf_t;
typedef struct wanif_conf wanif_conf_t;

typedef struct wan_device
{
        unsigned magic;
        char* name;
        void* private;
        unsigned config_id;
        unsigned ioport;
        char S514_cpu_no[1];
        unsigned char S514_slot_no;
        unsigned long maddr;
        unsigned msize;
        int irq;
        int dma;
        unsigned bps;
        unsigned mtu;
        unsigned udp_port;
        unsigned char ttl;
        unsigned enable_tx_int;
        char interface;
        char clocking;
        char line_coding;
        char station;
        char connection;
        char signalling;
        char read_mode;
        char new_if_cnt;
        char del_if_cnt;
        unsigned char piggyback;
        unsigned hw_opt[4];
        char state;
        char api_status;
        struct net_device_stats stats;
        unsigned reserved[16];
        unsigned long critical;
        spinlock_t lock;
        int (*setup) (struct wan_device *wandev, wandev_conf_t *conf);
        int (*shutdown) (struct wan_device *wandev);
        int (*update) (struct wan_device *wandev);
        int (*ioctl) (struct wan_device *wandev, unsigned cmd,
                unsigned long arg);
        int (*new_if) (struct wan_device *wandev, struct net_device *dev,
                wanif_conf_t *conf);
        int (*del_if) (struct wan_device *wandev, struct net_device *dev);
        struct wan_device* next;
        struct net_device* dev;
        unsigned ndev;
        struct proc_dir_entry *dent;
} wan_device_t;

struct net_proto_family
{
        int family;
        int (*create)(struct socket *sock, int protocol);
        short authentication;
        short encryption;
        short encrypt_net;
};

struct termios {
        tcflag_t c_iflag;
        tcflag_t c_oflag;
        tcflag_t c_cflag;
        tcflag_t c_lflag;
        cc_t c_line;
        cc_t c_cc[19];
};

struct tty_driver {
        int magic;
        const char *driver_name;
        const char *name;
        int name_base;
        short major;
        short minor_start;
        short num;
        short type;
        short subtype;
        struct termios init_termios;
        int flags;
        int *refcount;
        struct proc_dir_entry *proc_entry;
        struct tty_driver *other;
        struct tty_struct **table;
        struct termios **termios;
        struct termios **termios_locked;
        void *driver_state;
        int (*open)(struct tty_struct * tty, struct file * filp);
        void (*close)(struct tty_struct * tty, struct file * filp);
        int (*write)(struct tty_struct * tty, int from_user,
                      const unsigned char *buf, int count);
        void (*put_char)(struct tty_struct *tty, unsigned char ch);
        void (*flush_chars)(struct tty_struct *tty);
        int (*write_room)(struct tty_struct *tty);
        int (*chars_in_buffer)(struct tty_struct *tty);
        int (*ioctl)(struct tty_struct *tty, struct file * file,
                    unsigned int cmd, unsigned long arg);
        void (*set_termios)(struct tty_struct *tty, struct termios * old);
        void (*throttle)(struct tty_struct * tty);
        void (*unthrottle)(struct tty_struct * tty);
        void (*stop)(struct tty_struct *tty);
        void (*start)(struct tty_struct *tty);
        void (*hangup)(struct tty_struct *tty);
        void (*break_ctl)(struct tty_struct *tty, int state);
        void (*flush_buffer)(struct tty_struct *tty);
        void (*set_ldisc)(struct tty_struct *tty);
        void (*wait_until_sent)(struct tty_struct *tty, int timeout);
        void (*send_xchar)(struct tty_struct *tty, char ch);
        int (*read_proc)(char *page, char **start, off_t off,
                          int count, int *eof, void *data);
        int (*write_proc)(struct file *file, const char *buffer,
                          unsigned long count, void *data);
        struct tty_driver *next;
        struct tty_driver *prev;
};

struct tty_ldisc {
        int magic;
        char *name;
        int num;
        int flags;
        int (*open)(struct tty_struct *);
        void (*close)(struct tty_struct *);
        void (*flush_buffer)(struct tty_struct *tty);
        ssize_t (*chars_in_buffer)(struct tty_struct *tty);
        ssize_t (*read)(struct tty_struct * tty, struct file * file,
                        unsigned char * buf, size_t nr);
        ssize_t (*write)(struct tty_struct * tty, struct file * file,
                         const unsigned char * buf, size_t nr);
        int (*ioctl)(struct tty_struct * tty, struct file * file,
                         unsigned int cmd, unsigned long arg);
        void (*set_termios)(struct tty_struct *tty, struct termios * old);
        unsigned int (*poll)(struct tty_struct *, struct file *,
                             struct poll_table_struct *);
        void (*receive_buf)(struct tty_struct *, const unsigned char *cp,
                               char *fp, int count);
        int (*receive_room)(struct tty_struct *);
        void (*write_wakeup)(struct tty_struct *);
};

struct tasklet_struct
{
        struct tasklet_struct *next;
        unsigned long state;
        atomic_t count;
        void (*func)(unsigned long);
        unsigned long data;
};

struct tq_struct {
        struct list_head list;
        unsigned long sync;
        void (*routine)(void *);
        void *data;
};

typedef int gifconf_func_t(struct net_device * dev, char * bufptr, int len);

struct pci_driver * pcidrv_stub;
struct file_operations * fops_stub;
struct block_device_operations * bops_stub;
void (*handler_stub)(int, void *, struct pt_regs *);
int (*pm_callback_stub)(struct pm_dev *dev, pm_request_t rqst, void *data);
int (*gifconf_stub)(struct net_device * dev, char * bufptr, int len);
struct super_block *(*read_super_stub) (struct super_block *, void *, int);
struct gendisk * gendisk_stub;
struct net_device * net_device_stub;
struct notifier_block * notifier_block_stub;
struct ctl_table * ctl_table_stub;
int (*rcvfunc_stub)(struct sk_buff *, struct net_device *, struct packet_type *);
wan_device_t * wandev_stub;
struct net_proto_family * net_proto_family_stub;
struct tty_driver * tty_driver_stub;
struct tty_ldisc * tty_ldisc_stub;
struct tasklet_struct * tasklet_struct_stub;
struct tq_struct * tq_struct_stub;

int schedule_task(struct tq_struct *task) {
  tq_struct_stub = task;
}

void tasklet_init(struct tasklet_struct *t,
		  void (*func)(unsigned long), unsigned long data) {
        t->next = ((void *)0);
        t->state = 0;
        (((&t->count)->counter) = (0));
        t->func = func;
        t->data = data;
}

void __tasklet_schedule(struct tasklet_struct *t) {
  tasklet_struct_stub = t;
}

void __tasklet_hi_schedule(struct tasklet_struct *t) {
  tasklet_struct_stub = t;
}

int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc) {
  tty_ldisc_stub = new_ldisc;
}

int tty_register_driver(struct tty_driver *driver) {
  tty_driver_stub = driver;
  return 0;
}

void tty_register_devfs (struct tty_driver *driver, unsigned int flags, unsigned minor) {
  tty_driver_stub = driver;
}

int sock_register(struct net_proto_family *ops) {
  net_proto_family_stub = ops;
  return 0;
}

int register_wan_device(wan_device_t *wandev) {
  wandev_stub = wandev;
  return 0;
}

int register_trdev(struct net_device *dev) {
  net_device_stub = dev;
  return 0;
}

struct ctl_table_header * register_sysctl_table(ctl_table * table,
                                                int insert_at_head) {
  ctl_table_stub = table;
  return (void *)0;
}

struct datalink_proto *register_snap_client(unsigned char *desc, int (*rcvfunc)(struct sk_buff *, struct net_device *, struct packet_type *)) {
  rcvfunc_stub = rcvfunc;
  return (void *)0;
}

int register_reboot_notifier(struct notifier_block *nb) {
  notifier_block_stub = nb;
  return 0;
}

int register_netdevice_notifier(struct notifier_block *nb) {
  notifier_block_stub = nb;
  return 0;
}

int register_netdevice(struct net_device *dev) {
  net_device_stub = dev;
  return 0;
}

int register_netdev(struct net_device *dev) {
  net_device_stub = dev;
  return 0;
}

int register_gifconf(unsigned int family, gifconf_func_t * gifconf) {
  gifconf_stub = gifconf;
  return 0;
}

int register_filesystem(struct file_system_type * fs) {
  read_super_stub = fs->read_super;
  return 0;
}

int register_fcdev(struct net_device *dev) {
  net_device_stub = dev;
  return 0;
}

void register_disk(struct gendisk *dev, kdev_t first, unsigned minors, struct block_device_operations *ops, long size) {
  bops_stub = dev->fops;
  bops_stub = ops;
}

struct pm_dev *pm_register(pm_dev_t type, unsigned long id, 
			   pm_callback callback) {
  pm_callback_stub = callback;
  return (void *)0;
}

int pci_register_driver(struct pci_driver *drv) {
  pcidrv_stub = drv;
  return 0;
}

int misc_register(struct miscdevice * misc) {
  fops_stub = misc->fops;;
  return 0;
}

void devfs_register_partitions (struct gendisk *dev, int minor,
                                       int unregister)
{
  bops_stub = dev->fops;
}

int register_chrdev(unsigned int major, const char *name, struct file_operations *fops)
{
  fops_stub = fops;
  return 0;
}

int register_blkdev(unsigned int major, const char *name, struct block_device_operations * bops) 
{
  bops_stub = bops;
  return 0;
}


int request_irq(unsigned int irq,
		void (*handler)(int, void *, struct pt_regs *) ,
		unsigned long flags, const char * dev_name, void * dev_id) 
{
  handler_stub = handler;
  return 0;
}



void main(void)
{
  init_module();
  
  while (1) {
    if (1)
      rcvfunc_stub((void *)0, (void *)0, (void *)0);
    else if (1)
      gifconf_stub((void *)0, (void *)0, 0);
    else if (1)
      read_super_stub((void *)0, (void *)0, 0);
    else if (1)
      pm_callback_stub((void *)0, 0, (void *)0);
    else if (1)
      handler_stub(1, (void *)0, (void *)0);
    else if (1)
      fops_stub->llseek((void *)0, 0, 0);
    else if (1)
      fops_stub->read((void *)0, (void *)0, 0, (void *)0);
    else if (1)
      fops_stub->write((void *)0, (void *)0, 0, (void *)0);
    else if (1)
      fops_stub->readdir((void *)0, (void *)0, (void *)0);
    else if (1)
      fops_stub->poll((void *)0, (void *)0);
    else if (1)
      fops_stub->ioctl((void *)0, (void *)0, 0, 0);
    else if (1)
      fops_stub->mmap((void *)0, (void *)0);
    else if (1)
      fops_stub->open((void *)0, (void *)0);
    else if (1)
      fops_stub->flush((void *)0);
    else if (1)
      fops_stub->release((void *)0, (void *)0);
    else if (1)
      fops_stub->fsync((void *)0, (void *)0, 0);
    else if (1)
      fops_stub->fasync(0, (void *)0, 0);
    else if (1)
      fops_stub->lock((void *)0, 0, (void *)0);
    else if (1)
      fops_stub->readv((void *)0, (void *)0, 0, (void *)0);
    else if (1)
      fops_stub->writev((void *)0, (void *)0, 0, (void *)0);
    else if (1)
      fops_stub->sendpage((void *)0, (void *)0, 0, 0, (void *)0, 0);
    else if (1)
      fops_stub->get_unmapped_area((void *)0, 0, 0, 0, 0);
    else if (1)
      bops_stub->open((void *)0, (void *)0);
    else if (1)
      bops_stub->release((void *)0, (void *)0);
    else if (1)
      bops_stub->ioctl((void *)0, (void *)0, 0, 0);
    else if (1)
      bops_stub->check_media_change(0);
    else if (1)
      bops_stub->revalidate(0);
    else if (1)
      pcidrv_stub->probe((void *)0, (void *)0);
    else if (1)
      pcidrv_stub->remove((void *)0);
    else if (1)
      pcidrv_stub->save_state((void *)0, 0);
    else if (1)
      pcidrv_stub->suspend((void *)0, 0);
    else if (1)
      pcidrv_stub->resume((void *)0);
    else if (1)
      pcidrv_stub->enable_wake((void *)0, 0, 0);
    else if (1)
      net_device_stub->init((void *)0);
    else if (1)
      net_device_stub->get_stats((void *)0);
    else if (1)
      net_device_stub->get_wireless_stats((void *)0);
    else if (1)
      net_device_stub->uninit((void *)0);
    else if (1)
      net_device_stub->destructor((void *)0);
    else if (1)
      net_device_stub->open((void *)0);
    else if (1)
      net_device_stub->stop((void *)0);
    else if (1)
      net_device_stub->hard_start_xmit((void *)0, (void *)0);
    else if (1)
      net_device_stub->rebuild_header((void *)0);
    else if (1)
      net_device_stub->set_multicast_list((void *)0);
    else if (1)
      net_device_stub->set_mac_address((void *)0, (void *)0);
    else if (1)
      net_device_stub->do_ioctl((void *)0, (void *)0, 0);
    else if (1)
      net_device_stub->set_config((void *)0, (void *)0);
    else if (1)
      net_device_stub->hard_header_cache((void *)0, (void *)0);
    else if (1)
      net_device_stub->header_cache_update((void *)0, (void *)0, (void *)0);
    else if (1)
      net_device_stub->change_mtu((void *)0, 0);
    else if (1)
      net_device_stub->tx_timeout((void *)0);
    else if (1)
      net_device_stub->hard_header_parse((void *)0, (void *)0);
    else if (1)
      net_device_stub->neigh_setup((void *)0, (void *)0);
    else if (1)
      net_device_stub->accept_fastpath((void *)0, (void *)0);
    else if (1)
      notifier_block_stub->notifier_call((void *)0, 0, (void *)0);
    else if (1)
      ctl_table_stub->proc_handler((void *)0, 0, (void *)0, (void *)0, (void *)0);
    else if (1)
      ctl_table_stub->strategy((void *)0, (void *)0, 0, (void *)0, (void *)0, (void *)0, 0, (void *)0);
    else if (1)
      wandev_stub->setup((void *)0, (void *)0);
    else if (1)
      wandev_stub->shutdown((void *)0);
    else if (1)
      wandev_stub->update((void *)0);
    else if (1)
      wandev_stub->ioctl((void *)0, 0, 0);
    else if (1)
      wandev_stub->new_if((void *)0, (void *)0, (void *)0);
    else if (1)
      wandev_stub->del_if((void *)0, (void *)0);
    else if (1)
      net_proto_family_stub->create((void *)0, 0);
    else if (1)
      tty_driver_stub->open((void *)0, (void *)0);
    else if (1)
      tty_driver_stub->close((void *)0, (void *)0);
    else if (1)
      tty_driver_stub->write((void *)0, 0, (void *)0, 0);
    else if (1)
      tty_driver_stub->put_char((void *)0, 0);
    else if (1)
      tty_driver_stub->flush_chars((void *)0);
    else if (1)
      tty_driver_stub->write_room((void *)0);
    else if (1)
      tty_driver_stub->chars_in_buffer((void *)0);
    else if (1)
      tty_driver_stub->ioctl((void *)0, (void *)0, 0, 0);
    else if (1)
      tty_driver_stub->set_termios((void *)0, (void *)0);
    else if (1)
      tty_driver_stub->throttle((void *)0);
    else if (1)
      tty_driver_stub->unthrottle((void *)0);
    else if (1)
      tty_driver_stub->stop((void *)0);
    else if (1)
      tty_driver_stub->start((void *)0);
    else if (1)
      tty_driver_stub->hangup((void *)0);
    else if (1)
      tty_driver_stub->break_ctl((void *)0, 0);
    else if (1)
      tty_driver_stub->flush_buffer((void *)0);
    else if (1)
      tty_driver_stub->set_ldisc((void *)0);
    else if (1)
      tty_driver_stub->wait_until_sent((void *)0, 0);
    else if (1)
      tty_driver_stub->send_xchar((void *)0, 0);
    else if (1)
      tty_driver_stub->read_proc((void *)0, (void *)0, 0, 0, (void *)0, (void *)0);
    else if (1)
      tty_driver_stub->write_proc((void *)0, (void *)0, 0, (void *)0);
    else if (1)
      tty_ldisc_stub->open((void *)0);
    else if (1)
      tty_ldisc_stub->close((void *)0);
    else if (1)
      tty_ldisc_stub->flush_buffer((void *)0);
    else if (1)
      tty_ldisc_stub->chars_in_buffer((void *)0);
    else if (1)
      tty_ldisc_stub->read((void *)0, (void *)0, (void *)0, 0);
    else if (1)
      tty_ldisc_stub->write((void *)0, (void *)0, (void *)0, 0);
    else if (1)
      tty_ldisc_stub->ioctl((void *)0, (void *)0, 0, 0);
    else if (1)
      tty_ldisc_stub->set_termios((void *)0, (void *)0);
    else if (1)
      tty_ldisc_stub->poll((void *)0, (void *)0, (void *)0);
    else if (1)
      tty_ldisc_stub->receive_buf((void *)0, (void *)0, (void *)0, 0);
    else if (1)
      tty_ldisc_stub->receive_room((void *)0);
    else if (1)
      tty_ldisc_stub->write_wakeup((void *)0);
    else if (1)
      tasklet_struct_stub->func(0);
    else if (1)
      tq_struct_stub->routine((void *)0);
    else
      break;
  }   

  cleanup_module();
}

See more files for this project here

CQual

CQual - A tool for adding type qualifiers to C

Project homepage: http://sourceforge.net/projects/cqual
Programming language(s): C,Java,Shell Script
License: other

  analyze
  analyze-char
  analyze-file
  analyze-kernel
  analyze-pldi02
  analyze-taint
  analyze_sleepy
  analyze_together
  collected_dependencies
  find-mod.pl
  modules_main.c
  modules_main_sleepy.i
  report
  report-init
  report-man
  report-sendmail
  report-thesis.pl
  report.pl
  report_modules_classified
  strong-upd-errs