带debug功能的malloc和free。
可以探测的错误有4种，header和footer被破坏，重复free，内存泄漏检测。
/* Declarations for This software.
Author : stoneJam
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdlib.h>
#include <string.h>
#include "debugmalloc.h"
#include "dmhelper.h"
#include <stdio.h>
//struct of payload wrapper
typedef struct PayloadWrapper{
int ID;
int Checksum;
int SizeOfBlock;
char* Filename;
int Linenumber;
char* PayloadWithFence;
struct PayloadWrapper* NextBlock;
} *PayloadWrapperList ;
static struct PayloadWrapper* HeadBlock=NULL;
static int CurrentlyAllocatedBlocks =0 ;
//marocs of constants
#define FENCE 0xCCDEADCC
#define HEADERFENCESIZE sizeof(int)
#define FOOTERFENCESIZE sizeof(int)
#define CHECKSUMSIZE sizeof(int)
//method for calculate checksum(cs)
unsigned int calculate_check_sum(PayloadWrapperList pw){
int re = 0;
PayloadWrapperList p = pw;
int temp = 0;
temp = p->ID;
while (temp != 0 ){
if (temp&0x1) re++;
temp = temp>>1;
}
temp = p->Linenumber;
while (temp != 0 ){
if (temp&0x1) re++;
temp = temp>>1;
}
temp = p->SizeOfBlock;
while (temp != 0 ){
if (temp&0x1) re++;
temp = temp>>1;
}
return re;
}
/* Wrappers for malloc and free */
void *MyMalloc(size_t size, char *filename, int linenumber) {
//malloc for payloadwrapper
PayloadWrapperList tempPtr = (PayloadWrapperList)malloc(sizeof(struct
PayloadWrapper));
//calculate the whole size needed by payload with header and footer
size_t PLAddFenceSize = size + HEADERFENCESIZE + FOOTERFENCESIZE + CHECKSUMSIZE;
//malloc for filename(fn)
int len = 400;
char* fn = (char*)malloc(len);
//malloc for payload(PL) with fence and checksum info
char* pl = (char*) malloc(PLAddFenceSize);
//failed to malloc mem for tempPtr
if (!tempPtr) return NULL;
if (!pl){
free(tempPtr);
return NULL;
}
//assign ID
tempPtr->ID = (int)(pl+CHECKSUMSIZE+HEADERFENCESIZE);
//assign sob
tempPtr->SizeOfBlock = size;
//assign fn
if(!fn){
free(pl);
free(tempPtr);
return NULL;
}
strcpy(fn,filename);
tempPtr->Filename = fn;
//assign ln
tempPtr->Linenumber = linenumber;
//assign cs
tempPtr->Checksum = calculate_check_sum(tempPtr);
//assign pl with fence and checksum head
tempPtr->PayloadWithFence = pl;
*((int*)pl) = tempPtr->Checksum;
*((int*)(pl+HEADERFENCESIZE)) = FENCE;
pl = (char*)pl + HEADERFENCESIZE + CHECKSUMSIZE;
*(int*)(pl+size) = FENCE;
//add to the pwList
if(HeadBlock==NULL){
HeadBlock = tempPtr;
tempPtr->NextBlock = NULL;
}else{
tempPtr->NextBlock = HeadBlock;
HeadBlock = tempPtr;
}
//update CurrentlyAllocatedBlock
CurrentlyAllocatedBlocks += size;
return ((void*) pl);
}
// this method is designed for getting the PWL rect which has the
// ID equals to id
PayloadWrapperList get_payloadwrapperlist(int id){
PayloadWrapperList p = NULL;
if(HeadBlock==NULL) return NULL;
p = HeadBlock;
while(p){
if(p->ID == id)
return p;
p = p->NextBlock;
}
return NULL;
}
//method to get the previous PWL rect of the cpwl
PayloadWrapperList get_prePWL(PayloadWrapperList cpwl){
PayloadWrapperList p = NULL;
PayloadWrapperList q = NULL;
p = get_payloadwrapperlist(cpwl->ID);
//pwl isn't in the list
if (p==NULL) {
printf("Strange Error. *_* \n");
exit(0);
}
//none prePwl exits
if (((PayloadWrapperList)HeadBlock->ID) == (cpwl->ID))
return NULL;
//search for prePWL
p = HeadBlock;
q = p->NextBlock;
while(q!=NULL){
if (q->ID == cpwl->ID)
return p;
}
}
//method to remove pwl from the PWL
void remove_from_pwl(PayloadWrapperList pwl){
PayloadWrapperList prePWL = get_prePWL(pwl);
if (prePWL == NULL){
HeadBlock = NULL;
}else{
prePWL->NextBlock = pwl->NextBlock;
}
}
void MyFree(void *ptr, char *filename, int linenumber) {
PayloadWrapperList pwl = get_payloadwrapperlist((int)ptr);
char* temp = (char* )ptr - HEADERFENCESIZE;
int tempInt = *(int*)(temp - CHECKSUMSIZE);
//"Attempting to free an unallocated block.";
if (!pwl) error(4, filename, linenumber);
//"Starting edge of the payload has been overwritten.";
if ( *((int*)temp) != FENCE )
errorfl(1, pwl->Filename, pwl->Linenumber, filename, linenumber);
//"Ending edge of the payload has been overwritten.";
temp = (char*)ptr + pwl->SizeOfBlock;
if ( *((int*)temp) != FENCE )
errorfl(2, pwl->Filename, pwl->Linenumber, filename, linenumber);
//"Header has been corrupted.";
temp = (char*)ptr -HEADERFENCESIZE - CHECKSUMSIZE;
if (*((int*)temp) != (pwl->Checksum))
errorfl(3, pwl->Filename, pwl->Linenumber, filename, linenumber);
//update CurrentlyAllocatedBlocks
CurrentlyAllocatedBlocks -= pwl->SizeOfBlock;
//remove from the list
remove_from_pwl(pwl);
//free the whole mem associated with ptr
free(pwl->Filename);
free((void *)(pwl->PayloadWithFence) );
free(pwl);
}
/* returns number of bytes allocated using MyMalloc/MyFree:
used as a debugging tool to test for memory leaks */
int AllocatedSize() {
return CurrentlyAllocatedBlocks;
}
/* Optional functions */
/* Prints a list of all allocated blocks with the
filename/line number when they were MALLOC'd */
void PrintAllocatedBlocks() {
PayloadWrapperList p = HeadBlock;
if (p!=NULL)
printf("Currently allocated blocks:\n");
else
return;
while(p != NULL){
PRINTBLOCK(p->SizeOfBlock,p->Filename,p->Linenumber);
p = p->NextBlock;
}
return;
}
/* Goes through the currently allocated blocks and checks
to see if they are all valid.
Returns -1 if it receives an error, 0 if all blocks are
okay.
*/
int HeapCheck() {
PayloadWrapperList pwl = HeadBlock;
char* ptr = NULL;
char* temp = NULL;
int tempInt = 0;
int re = 0 ;
if (HeadBlock == NULL)
return re;
while(pwl != NULL){
temp = pwl->PayloadWithFence ;
if (!pwl){
PRINTERROR(4, pwl->Filename, pwl->Linenumber) ;
re = -1;
}
// "Header has been corrupted.";
if (*((int*)temp) != (pwl->Checksum)){
PRINTERROR(3, pwl->Filename, pwl->Linenumber) ;
re = -1;
}
// "Starting edge of the payload has been overwritten.";
temp = temp + CHECKSUMSIZE;
if ( *((int*)temp) != FENCE ){
PRINTERROR(1, pwl->Filename, pwl->Linenumber);
re = -1;
}
// "Ending edge of the payload has been overwritten.";
temp = temp + HEADERFENCESIZE+ pwl->SizeOfBlock;
if ( *((int*)temp) != FENCE ){
PRINTERROR(2, pwl->Filename, pwl->Linenumber);
re = -1;
}
pwl = pwl->NextBlock;
}
return re;
}
//这是相关的工程文件
[debugmalloc.h]
#ifndef DEBUGMALLOC_H
#define DEBUGMALLOC_H
#include <stdlib.h>
/* Macros that will call the wrapper functions with
the current filename and line number */
#define MALLOC(s) MyMalloc(s, __FILE__, __LINE__)
#define FREE(p) MyFree(p, __FILE__, __LINE__)
/* Wrappers for malloc and free. You will implement
these functions. */
void *MyMalloc(size_t size, char *filename, int linenumber);
void MyFree(void *ptr, char *filename, int linenumber);
/* Required function for detecting memory leaks */
int AllocatedSize(); /* returns number of bytes allocated */
/* Optional functions if you wish to implement the global list */
void PrintAllocatedBlocks();
int HeapCheck(); /* returns 0 if all blocks have not been corrupted,
-1 if an error is detected */
#endif
[dmhelper.c]
#include "dmhelper.h"
#include <stdio.h>
#include <stdlib.h>
/* returns 1 if c is in str, 0 if not */
int checkString(char *str, char c) {
while (*str++) {
if (*str == c) {
return 1;
}
}
return 0;
}
char *getMsg(int error) {
switch(error) {
case 1:
return "Starting edge of the payload has been overwritten.";
case 2:
return "Ending edge of the payload has been overwritten.";
case 3:
return "Header has been corrupted.";
case 4:
return "Attempting to free an unallocated block.";
}
return "";
}
/* Prints out an error message in a readable format, given
the message, filename and line number.
First checks to make sure '\n' does not exist in
msg and filename.
Returns 0 on success, -1 on failure. */
int error(int errorCode, char *filename, int linenumber) {
char *msg = getMsg(errorCode);
if (checkString(filename, '\n')) {
printf("Invalid filename\n");
return -1;
}
printf("Error: %s\n\tin block freed at %s, line %d\n", msg, filename, linenumber);
exit(-1);
}
int errorfl(int errorCode, char *filename_malloc, int linenumber_malloc, char *filename_free, int linenumber_free) {
char *msg = getMsg(errorCode);
if (checkString(filename_malloc, '\n')) {
printf("Invalid \"malloc\" filename\n");
return -1;
}
if (checkString(filename_free, '\n')) {
printf("Invalid \"free\" filename\n");
return -1;
}
printf("Error: %s\n\tin block allocated at %s, line %d\n", msg, filename_malloc, linenumber_malloc);
printf("\tand freed at %s, line %d\n", filename_free, linenumber_free);
exit(-1);
}
[dmhelper.h]
#ifndef DMHELPER_H
#define DMHELPER_H
/* Prints out an error message in a readable format, given
the message, filename and line number, then exits.
First checks to make sure '\n' does not exist in
msg and filename.
Returns 0 on success, -1 on failure. */
int error(int errorCode, char *filename, int linenumber);
/* Prints out an error message in a readable format, given
the message, filename and line number, then exits.
First checks to make sure '\n' does not exist in
msg and filename.
Returns 0 on success, -1 on failure. */
int errorfl(int errorCode, char *filename_malloc, int linenumber_malloc, char *filename_free, int linenumber_free);
char *getMsg(int error);
#define PRINTBLOCK(s, f, l) printf("\t%d bytes, created at %s, line %d\n", s, f, l)
#define PRINTERROR(e, f, l) printf("Error: %s\n\tInvalid block created at %s, line %d\n", getMsg(e), f, l);
#endif
[driver.c]
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
//#include <windows.h>
#include "getopt.h"
#include "debugmalloc.h"
#define NUMTESTCASES 8
static void run_test_case(int n) {
switch(n) {
case 1: { /* no error, just a basic test */
char *str = (char *) MALLOC(12);
strcpy(str, "123456789");
FREE(str);
printf("Size: %d\n", AllocatedSize());
PrintAllocatedBlocks();
}
break;
case 2: { /* should overflow by 1 */
char *str = (char *) MALLOC(8);
strcpy(str, "12345678");
FREE(str);
}
break;
case 3: { /* should overflow by 1, harder to catch
because of alignment */
char *str = (char *) MALLOC(2);
strcpy(str, "12");
FREE(str);
}
break;
case 4: { /* memory leak */
void *ptr = MALLOC(4), *ptr2 = MALLOC(6);
FREE(ptr);
printf("Size: %d\n", AllocatedSize());
PrintAllocatedBlocks();
}
break;
case 5: {
void *ptr = MALLOC(4);
FREE(ptr);
FREE(ptr);
}
break;
case 6: {
char *ptr = (char *) MALLOC(4);
*((int *) (ptr - 8)) = 8 + (1 << 31);
FREE(ptr);
}
break;
case 7: {
char ptr[5];
FREE(ptr);
}
break;
case 8: {
int i;
int *intptr = (int *) MALLOC(6);
char *str = (char *) MALLOC(12);
for(i = 0; i < 6; i++) {
intptr[i] = i;
}
if (HeapCheck() == -1) {
printf("\nCaught Errors\n");
}
}
default:
;
}
}
static void usage(char *cmd) {
printf("Usage: %s [-h] [-t <testnum>]\n", cmd);
printf(" -h Prints this message\n");
printf(" -t <n> Runs n-th test\n");
exit(1);
}
int main(int argc, char *argv[]) {
char c;
int tracenum = 0;
while ((c = getopt(argc, argv, "ht:")) != -1) {
switch (c) {
case 'h':
usage(argv[0]);
break;
case 't':
if ((tracenum = atoi(optarg)) > NUMTESTCASES || tracenum <= 0) {
usage(argv[0]);
}
break;
default:
usage(argv[0]);
}
}
if (tracenum) {
run_test_case(tracenum);
}
else {
usage(argv[0]);
}
return 0;
}
[getopt.c]
// Taken from http://lottery.merseyworld.com/Wheel/
/* Getopt for GNU.
NOTE: getopt is now part of the C library, so if you don't know what
"Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
before changing it!
Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifndef __STDC__
# ifndef const
# define const
# endif
#endif
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>. */
#ifndef _NO_PROTO
#define _NO_PROTO
#endif
#include <stdio.h>
#include "tailor.h"
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
/* This needs to come after some library #include
to get __GNU_LIBRARY__ defined. */
#ifdef __GNU_LIBRARY__
/* Don't include stdlib.h for non-GNU C libraries because some of them
contain conflicting prototypes for getopt. */
#include <stdlib.h>
#endif /* GNU C library. */
/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
long-named option. Because this is not POSIX.2 compliant, it is
being phased out. */
/* #define GETOPT_COMPAT */
/* This version of `getopt' appears to the caller like standard Unix `getopt'
but it behaves differently for the user, since it allows the user
to intersperse the options with the other arguments.
As `getopt' works, it permutes the elements of ARGV so that,
when it is done, all the options precede everything else. Thus
all application programs are extended to handle flexible argument order.
Setting the environment variable POSIXLY_CORRECT disables permutation.
Then the behavior is completely standard.
GNU application programs can use a third alternative mode in which
they can distinguish the relative order of options and other arguments. */
#include "getopt.h"
/* For communication from `getopt' to the caller.
When `getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
char *optarg = 0;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
and for communication between successive calls to `getopt'.
On entry to `getopt', zero means this is the first call; initialize.
When `getopt' returns EOF, this is the index of the first of the
non-option elements that the caller should itself scan.
Otherwise, `optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
/* XXX 1003.2 says this must be 1 before any call. */
int optind = 0;
/* The next char to be scanned in the option-element
in which the last option character we returned was found.
This allows us to pick up the scan where we left off.
If this is zero, or a null string, it means resume the scan
by advancing to the next ARGV-element. */
static char *nextchar;
/* Callers store zero here to inhibit the error message
for unrecognized options. */
int opterr = 1;
/* Set to an option character which was unrecognized.
This must be initialized on some systems to avoid linking in the
system's own getopt implementation. */
#define BAD_OPTION '\0'
int optopt = BAD_OPTION;
/* Describe how to deal with options that follow non-option ARGV-elements.
If the caller did not specify anything,
the default is REQUIRE_ORDER if the environment variable
POSIXLY_CORRECT is defined, PERMUTE otherwise.
REQUIRE_ORDER means don't recognize them as options;
stop option processing when the first non-option is seen.
This is what Unix does.
This mode of operation is selected by either setting the environment
variable POSIXLY_CORRECT, or using `+' as the first character
of the list of option characters.
PERMUTE is the default. We permute the contents of ARGV as we scan,
so that eventually all the non-options are at the end. This allows options
to be given in any order, even with programs that were not written to
expect this.
RETURN_IN_ORDER is an option available to programs that were written
to expect options and other ARGV-elements in any order and that care about
the ordering of the two. We describe each non-option ARGV-element
as if it were the argument of an option with character code 1.
Using `-' as the first character of the list of option characters
selects this mode of operation.
The special argument `--' forces an end of option-scanning regardless
of the value of `ordering'. In the case of RETURN_IN_ORDER, only
`--' can cause `getopt' to return EOF with `optind' != ARGC. */
static enum
{
REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
} ordering;
#ifdef __GNU_LIBRARY__
/* We want to avoid inclusion of string.h with non-GNU libraries
because there are many ways it can cause trouble.
On some systems, it contains special magic macros that don't work
in GCC. */
#include <string.h>
#define my_index strchr
#define my_strlen strlen
#else
/* Avoid depending on library functions or files
whose names are inconsistent. */
#if __STDC__ || defined(PROTO)
extern char *getenv(const char *name);
extern int strcmp (const char *s1, const char *s2);
extern int strncmp(const char *s1, const char *s2, int n);
static int my_strlen(const char *s);
static char *my_index (const char *str, int chr);
#else
extern char *getenv ();
#endif
static int
my_strlen (str)
const char *str;
{
int n = 0;
while (*str++)
n++;
return n;
}
static char *
my_index (str, chr)
const char *str;
int chr;
{
while (*str)
{
if (*str == chr)
return (char *) str;
str++;
}
return 0;
}
#endif /* GNU C library. */
/* Handle permutation of arguments. */
/* Describe the part of ARGV that contains non-options that have
been skipped. `first_nonopt' is the index in ARGV of the first of them;
`last_nonopt' is the index after the last of them. */
static int first_nonopt;
static int last_nonopt;
/* Exchange two adjacent subsequences of ARGV.
One subsequence is elements [first_nonopt,last_nonopt)
which contains all the non-options that have been skipped so far.
The other is elements [last_nonopt,optind), which contains all
the options processed since those non-options were skipped.
`first_nonopt' and `last_nonopt' are relocated so that they describe
the new indices of the non-options in ARGV after they are moved.
To perform the swap, we first reverse the order of all elements. So
all options now come before all non options, but they are in the
wrong order. So we put back the options and non options in original
order by reversing them again. For example:
original input: a b c -x -y
reverse all: -y -x c b a
reverse options: -x -y c b a
reverse non options: -x -y a b c
*/
#if __STDC__ || defined(PROTO)
static void exchange (char **argv);
#endif
static void
exchange (argv)
char **argv;
{
char *temp, **first, **last;
/* Reverse all the elements [first_nonopt, optind) */
first = &argv[first_nonopt];
last = &argv[optind-1];
while (first < last) {
temp = *first; *first = *last; *last = temp; first++; last--;
}
/* Put back the options in order */
first = &argv[first_nonopt];
first_nonopt += (optind - last_nonopt);
last = &argv[first_nonopt - 1];
while (first < last) {
temp = *first; *first = *last; *last = temp; first++; last--;
}
/* Put back the non options in order */
first = &argv[first_nonopt];
last_nonopt = optind;
last = &argv[last_nonopt-1];
while (first < last) {
temp = *first; *first = *last; *last = temp; first++; last--;
}
}
/* Scan elements of ARGV (whose length is ARGC) for option characters
given in OPTSTRING.
If an element of ARGV starts with '-', and is not exactly "-" or "--",
then it is an option element. The characters of this element
(aside from the initial '-') are option characters. If `getopt'
is called repeatedly, it returns successively each of the option characters
from each of the option elements.
If `getopt' finds another option character, it returns that character,
updating `optind' and `nextchar' so that the next call to `getopt' can
resume the scan with the following option character or ARGV-element.
If there are no more option characters, `getopt' returns `EOF'.
Then `optind' is the index in ARGV of the first ARGV-element
that is not an option. (The ARGV-elements have been permuted
so that those that are not options now come last.)
OPTSTRING is a string containing the legitimate option characters.
If an option character is seen that is not listed in OPTSTRING,
return BAD_OPTION after printing an error message. If you set `opterr' to
zero, the error message is suppressed but we still return BAD_OPTION.
If a char in OPTSTRING is followed by a colon, that means it wants an arg,
so the following text in the same ARGV-element, or the text of the following
ARGV-element, is returned in `optarg'. Two colons mean an option that
wants an optional arg; if there is text in the current ARGV-element,
it is returned in `optarg', otherwise `optarg' is set to zero.
If OPTSTRING starts with `-' or `+', it requests different methods of
handling the non-option ARGV-elements.
See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
Long-named options begin with `--' instead of `-'.
Their names may be abbreviated as long as the abbreviation is unique
or is an exact match for some defined option. If they have an
argument, it follows the option name in the same ARGV-element, separated
from the option name by a `=', or else the in next ARGV-element.
When `getopt' finds a long-named option, it returns 0 if that option's
`flag' field is nonzero, the value of the option's `val' field
if the `flag' field is zero.
The elements of ARGV aren't really const, because we permute them.
But we pretend they're const in the prototype to be compatible
with other systems.
LONGOPTS is a vector of `struct option' terminated by an
element containing a name which is zero.
LONGIND returns the index in LONGOPT of the long-named option found.
It is only valid when a long-named option has been found by the most
recent call.
If LONG_ONLY is nonzero, '-' as well as '--' can introduce
long-named options. */
int
_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
int argc;
char *const *argv;
const char *optstring;
const struct option *longopts;
int *longind;
int long_only;
{
int option_index;
optarg = 0;
/* Initialize the internal data when the first call is made.
Start processing options with ARGV-element 1 (since ARGV-element 0
is the program name); the sequence of previously skipped
non-option ARGV-elements is empty. */
if (optind == 0)
{
first_nonopt = last_nonopt = optind = 1;
nextchar = NULL;
/* Determine how to handle the ordering of options and nonoptions. */
if (optstring[0] == '-')
{
ordering = RETURN_IN_ORDER;
++optstring;
}
else if (optstring[0] == '+')
{
ordering = REQUIRE_ORDER;
++optstring;
}
else if (getenv ("POSIXLY_CORRECT") != NULL)
ordering = REQUIRE_ORDER;
else
ordering = PERMUTE;
}
if (nextchar == NULL || *nextchar == '\0')
{
if (ordering == PERMUTE)
{
/* If we have just processed some options following some non-options,
exchange them so that the options come first. */
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (last_nonopt != optind)
first_nonopt = optind;
/* Now skip any additional non-options
and extend the range of non-options previously skipped. */
while (optind < argc
&& (argv[optind][0] != '-' || argv[optind][1] == '\0')
#ifdef GETOPT_COMPAT
&& (longopts == NULL
|| argv[optind][0] != '+' || argv[optind][1] == '\0')
#endif /* GETOPT_COMPAT */
)
optind++;
last_nonopt = optind;
}
/* Special ARGV-element `--' means premature end of options.
Skip it like a null option,
then exchange with previous non-options as if it were an option,
then skip everything else like a non-option. */
if (optind != argc && !strcmp (argv[optind], "--"))
{
optind++;
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (first_nonopt == last_nonopt)
first_nonopt = optind;
last_nonopt = argc;
optind = argc;
}
/* If we have done all the ARGV-elements, stop the scan
and back over any non-options that we skipped and permuted. */
if (optind == argc)
{
/* Set the next-arg-index to point at the non-options
that we previously skipped, so the caller will digest them. */
if (first_nonopt != last_nonopt)
optind = first_nonopt;
return EOF;
}
/* If we have come to a non-option and did not permute it,
either stop the scan or describe it to the caller and pass it by. */
if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
#ifdef GETOPT_COMPAT
&& (longopts == NULL
|| argv[optind][0] != '+' || argv[optind][1] == '\0')
#endif /* GETOPT_COMPAT */
)
{
if (ordering == REQUIRE_ORDER)
return EOF;
optarg = argv[optind++];
return 1;
}
/* We have found another option-ARGV-element.
Start decoding its characters. */
nextchar = (argv[optind] + 1
+ (longopts != NULL && argv[optind][1] == '-'));
}
if (longopts != NULL
&& ((argv[optind][0] == '-'
&& (argv[optind][1] == '-' || long_only))
#ifdef GETOPT_COMPAT
|| argv[optind][0] == '+'
#endif /* GETOPT_COMPAT */
))
{
const struct option *p;
char *s = nextchar;
int exact = 0;
int ambig = 0;
const struct option *pfound = NULL;
int indfound = 0;
while (*s && *s != '=')
s++;
/* Test all options for either exact match or abbreviated matches. */
for (p = longopts, option_index = 0; p->name;
p++, option_index++)
if (!strncmp (p->name, nextchar, (int)(s - nextchar)))
{
if (s - nextchar == my_strlen (p->name))
{
/* Exact match found. */
pfound = p;
indfound = option_index;
exact = 1;
break;
}
else if (pfound == NULL)
{
/* First nonexact match found. */
pfound = p;
indfound = option_index;
}
else
/* Second nonexact match found. */
ambig = 1;
}
if (ambig && !exact)
{
if (opterr)
fprintf (stderr, "%s: option `%s' is ambiguous\n",
argv[0], argv[optind]);
nextchar += my_strlen (nextchar);
optind++;
return BAD_OPTION;
}
if (pfound != NULL)
{
option_index = indfound;
optind++;
if (*s)
{
/* Don't test has_arg with >, because some C compilers don't
allow it to be used on enums. */
if (pfound->has_arg)
optarg = s + 1;
else
{
if (opterr)
{
if (argv[optind - 1][1] == '-')
/* --option */
fprintf (stderr,
"%s: option `--%s' doesn't allow an
argument\n",
argv[0], pfound->name);
else
/* +option or -option */
fprintf (stderr,
"%s: option `%c%s' doesn't allow an
argument\n",
argv[0], argv[optind - 1][0],
pfound->name);
}
nextchar += my_strlen (nextchar);
return BAD_OPTION;
}
}
else if (pfound->has_arg == 1)
{
if (optind < argc)
optarg = argv[optind++];
else
{
if (opterr)
fprintf (stderr, "%s: option `%s' requires an argument\n",
argv[0], argv[optind - 1]);
nextchar += my_strlen (nextchar);
return optstring[0] == ':' ? ':' : BAD_OPTION;
}
}
nextchar += my_strlen (nextchar);
if (longind != NULL)
*longind = option_index;
if (pfound->flag)
{
*(pfound->flag) = pfound->val;
return 0;
}
return pfound->val;
}
/* Can't find it as a long option. If this is not getopt_long_only,
or the option starts with '--' or is not a valid short
option, then it's an error.
Otherwise interpret it as a short option. */
if (!long_only || argv[optind][1] == '-'
#ifdef GETOPT_COMPAT
|| argv[optind][0] == '+'
#endif /* GETOPT_COMPAT */
|| my_index (optstring, *nextchar) == NULL)
{
if (opterr)
{
if (argv[optind][1] == '-')
/* --option */
fprintf (stderr, "%s: unrecognized option `--%s'\n",
argv[0], nextchar);
else
/* +option or -option */
fprintf (stderr, "%s: unrecognized option `%c%s'\n",
argv[0], argv[optind][0], nextchar);
}
nextchar = (char *) "";
optind++;
return BAD_OPTION;
}
}
/* Look at and handle the next option-character. */
{
char c = *nextchar++;
char *temp = my_index (optstring, c);
/* Increment `optind' when we start to process its last character. */
if (*nextchar == '\0')
++optind;
if (temp == NULL || c == ':')
{
if (opterr)
{
#if 0
if (c < 040 || c >= 0177)
fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
argv[0], c);
else
fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
#else
/* 1003.2 specifies the format of this message. */
fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
#endif
}
optopt = c;
return BAD_OPTION;
}
if (temp[1] == ':')
{
if (temp[2] == ':')
{
/* This is an option that accepts an argument optionally. */
if (*nextchar != '\0')
{
optarg = nextchar;
optind++;
}
else
optarg = 0;
nextchar = NULL;
}
else
{
/* This is an option that requires an argument. */
if (*nextchar != '\0')
{
optarg = nextchar;
/* If we end this ARGV-element by taking the rest as an arg,
we must advance to the next element now. */
optind++;
}
else if (optind == argc)
{
if (opterr)
{
#if 0
fprintf (stderr, "%s: option `-%c' requires an argument\n",
argv[0], c);
#else
/* 1003.2 specifies the format of this message. */
fprintf (stderr, "%s: option requires an argument -- %c\n",
argv[0], c);
#endif
}
optopt = c;
if (optstring[0] == ':')
c = ':';
else
c = BAD_OPTION;
}
else
/* We already incremented `optind' once;
increment it again when taking next ARGV-elt as argument. */
optarg = argv[optind++];
nextchar = NULL;
}
}
return c;
}
}
int
getopt (argc, argv, optstring)
int argc;
char *const *argv;
const char *optstring;
{
return _getopt_internal (argc, argv, optstring,
(const struct option *) 0,
(int *) 0,
0);
}
int
getopt_long (argc, argv, options, long_options, opt_index)
int argc;
char *const *argv;
const char *options;
const struct option *long_options;
int *opt_index;
{
return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
}
#endif /* _LIBC or not __GNU_LIBRARY__. */
#ifdef TEST
/* Compile with -DTEST to make an executable for use in testing
the above definition of `getopt'. */
int
main (argc, argv)
int argc;
char **argv;
{
int c;
int digit_optind = 0;
while (1)
{
int this_option_optind = optind ? optind : 1;
c = getopt (argc, argv, "abc:d:0123456789");
if (c == EOF)
break;
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (digit_optind != 0 && digit_optind != this_option_optind)
printf ("digits occur in two different argv-elements.\n");
digit_optind = this_option_optind;
printf ("option %c\n", c);
break;
case 'a':
printf ("option a\n");
break;
case 'b':
printf ("option b\n");
break;
case 'c':
printf ("option c with value `%s'\n", optarg);
break;
case BAD_OPTION:
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
printf ("\n");
}
exit (0);
}
#endif /* TEST */
[getopt.h]
/* Declarations for getopt.
Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifndef _GETOPT_H
#define _GETOPT_H 1
#ifdef __cplusplus
extern "C" {
#endif
/* For communication from `getopt' to the caller.
When `getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
extern char *optarg;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
and for communication between successive calls to `getopt'.
On entry to `getopt', zero means this is the first call; initialize.
When `getopt' returns EOF, this is the index of the first of the
non-option elements that the caller should itself scan.
Otherwise, `optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
extern int optind;
/* Callers store zero here to inhibit the error message `getopt' prints
for unrecognized options. */
extern int opterr;
/* Set to an option character which was unrecognized. */
extern int optopt;
/* Describe the long-named options requested by the application.
The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
of `struct option' terminated by an element containing a name which is
zero.
The field `has_arg' is:
no_argument (or 0) if the option does not take an argument,
required_argument (or 1) if the option requires an argument,
optional_argument (or 2) if the option takes an optional argument.
If the field `flag' is not NULL, it points to a variable that is set
to the value given in the field `val' when the option is found, but
left unchanged if the option is not found.
To have a long-named option do something other than set an `int' to
a compiled-in constant, such as set a value from `optarg', set the
option's `flag' field to zero and its `val' field to a nonzero
value (the equivalent single-letter option character, if there is
one). For long options that have a zero `flag' field, `getopt'
returns the contents of the `val' field. */
struct option
{
#if __STDC__
const char *name;
#else
char *name;
#endif
/* has_arg can't be an enum because some compilers complain about
type mismatches in all the code that assumes it is an int. */
int has_arg;
int *flag;
int val;
};
/* Names for the values of the `has_arg' field of `struct option'. */
#define no_argument 0
#define required_argument 1
#define optional_argument 2
#if __STDC__ || defined(PROTO)
#if defined(__GNU_LIBRARY__)
/* Many other libraries have conflicting prototypes for getopt, with
differences in the consts, in stdlib.h. To avoid compilation
errors, only prototype getopt for the GNU C library. */
extern int getopt (int argc, char *const *argv, const char *shortopts);
#endif /* not __GNU_LIBRARY__ */
extern int getopt_long (int argc, char *const *argv, const char *shortopts,
const struct option *longopts, int *longind);
extern int getopt_long_only (int argc, char *const *argv,
const char *shortopts,
const struct option *longopts, int *longind);
/* Internal only. Users should not call this directly. */
extern int _getopt_internal (int argc, char *const *argv,
const char *shortopts,
const struct option *longopts, int *longind,
int long_only);
#else /* not __STDC__ */
extern int getopt ();
extern int getopt_long ();
extern int getopt_long_only ();
extern int _getopt_internal ();
#endif /* not __STDC__ */
#ifdef __cplusplus
}
#endif
#endif /* _GETOPT_H */
[tailor.h]
/* tailor.h -- target dependent definitions
* Copyright (C) 1992-1993 Jean-loup Gailly.
* This is free software; you can redistribute it and/or modify it under the
* terms of the GNU General Public License, see the file COPYING.
*/
/* The target dependent definitions should be defined here only.
* The target dependent functions should be defined in tailor.c.
*/
/* $Id: tailor.h,v 0.18 1993/06/14 19:32:20 jloup Exp $ */
#if defined(__MSDOS__) && !defined(MSDOS)
# define MSDOS
#endif
#if defined(__OS2__) && !defined(OS2)
# define OS2
#endif
#if defined(OS2) && defined(MSDOS) /* MS C under OS/2 */
# undef MSDOS
#endif
#ifdef MSDOS
# ifdef __GNUC__
/* DJGPP version 1.09+ on MS-DOS.
* The DJGPP 1.09 stat() function must be upgraded before gzip will
* fully work.
* No need for DIRENT, since <unistd.h> defines POSIX_SOURCE which
* implies DIRENT.
*/
# define near
# else
# define MAXSEG_64K
# ifdef __TURBOC__
# define NO_OFF_T
# ifdef __BORLANDC__
# define DIRENT
# else
# define NO_UTIME
# endif
# else /* MSC */
# define HAVE_SYS_UTIME_H
# define NO_UTIME_H
# endif
# endif
# define PATH_SEP2 '\\'
# define PATH_SEP3 ':'
# define MAX_PATH_LEN 128
# define NO_MULTIPLE_DOTS
# define MAX_EXT_CHARS 3
# define Z_SUFFIX "z"
# define NO_CHOWN
# define PROTO
# define STDC_HEADERS
# define NO_SIZE_CHECK
# define casemap(c) tolow(c) /* Force file names to lower case */
# include <io.h>
# define OS_CODE 0x00
# define SET_BINARY_MODE(fd) setmode(fd, O_BINARY)
# if !defined(NO_ASM) && !defined(ASMV)
# define ASMV
# endif
#else
# define near
#endif
#ifdef OS2
# define PATH_SEP2 '\\'
# define PATH_SEP3 ':'
# define MAX_PATH_LEN 260
# ifdef OS2FAT
# define NO_MULTIPLE_DOTS
# define MAX_EXT_CHARS 3
# define Z_SUFFIX "z"
# define casemap(c) tolow(c)
# endif
# define NO_CHOWN
# define PROTO
# define STDC_HEADERS
# include <io.h>
# define OS_CODE 0x06
# define SET_BINARY_MODE(fd) setmode(fd, O_BINARY)
# ifdef _MSC_VER
# define HAVE_SYS_UTIME_H
# define NO_UTIME_H
# define MAXSEG_64K
# undef near
# define near _near
# endif
# ifdef __EMX__
# define HAVE_SYS_UTIME_H
# define NO_UTIME_H
# define DIRENT
# define EXPAND(argc,argv) \
{_response(&argc, &argv); _wildcard(&argc, &argv);}
# endif
# ifdef __BORLANDC__
# define DIRENT
# endif
# ifdef __ZTC__
# define NO_DIR
# define NO_UTIME_H
# include <dos.h>
# define EXPAND(argc,argv) \
{response_expand(&argc, &argv);}
# endif
#endif
#ifdef WIN32 /* Windows NT */
# define HAVE_SYS_UTIME_H
# define NO_UTIME_H
# define PATH_SEP2 '\\'
# define PATH_SEP3 ':'
# define MAX_PATH_LEN 260
# define NO_CHOWN
# define PROTO
# define STDC_HEADERS
# define SET_BINARY_MODE(fd) setmode(fd, O_BINARY)
# include <io.h>
# include <malloc.h>
# ifdef NTFAT
# define NO_MULTIPLE_DOTS
# define MAX_EXT_CHARS 3
# define Z_SUFFIX "z"
# define casemap(c) tolow(c) /* Force file names to lower case */
# endif
# define OS_CODE 0x0b
#endif
#ifdef MSDOS
# ifdef __TURBOC__
# include <alloc.h>
# define DYN_ALLOC
/* Turbo C 2.0 does not accept static allocations of large arrays */
void * fcalloc (unsigned items, unsigned size);
void fcfree (void *ptr);
# else /* MSC */
# include <malloc.h>
# define fcalloc(nitems,itemsize) halloc((long)(nitems),(itemsize))
# define fcfree(ptr) hfree(ptr)
# endif
#else
# ifdef MAXSEG_64K
# define fcalloc(items,size) calloc((items),(size))
# else
# define fcalloc(items,size) malloc((size_t)(items)*(size_t)(size))
# endif
# define fcfree(ptr) free(ptr)
#endif
#if defined(VAXC) || defined(VMS)
# define PATH_SEP ']'
# define PATH_SEP2 ':'
# define SUFFIX_SEP ';'
# define NO_MULTIPLE_DOTS
# define Z_SUFFIX "-gz"
# define RECORD_IO 1
# define casemap(c) tolow(c)
# define OS_CODE 0x02
# define OPTIONS_VAR "GZIP_OPT"
# define STDC_HEADERS
# define NO_UTIME
# define EXPAND(argc,argv) vms_expand_args(&argc,&argv);
# include <file.h>
# define unlink delete
# ifdef VAXC
# define NO_FCNTL_H
# include <unixio.h>
# endif
#endif
#ifdef AMIGA
# define PATH_SEP2 ':'
# define STDC_HEADERS
# define OS_CODE 0x01
# define ASMV
# ifdef __GNUC__
# define DIRENT
# define HAVE_UNISTD_H
# else /* SASC */
# define NO_STDIN_FSTAT
# define SYSDIR
# define NO_SYMLINK
# define NO_CHOWN
# define NO_FCNTL_H
# include <fcntl.h> /* for read() and write() */
# define direct dirent
extern void _expand_args(int *argc, char ***argv);
# define EXPAND(argc,argv) _expand_args(&argc,&argv);
# undef O_BINARY /* disable useless --ascii option */
# endif
#endif
#if defined(ATARI) || defined(atarist)
# ifndef STDC_HEADERS
# define STDC_HEADERS
# define HAVE_UNISTD_H
# define DIRENT
# endif
# define ASMV
# define OS_CODE 0x05
# ifdef TOSFS
# define PATH_SEP2 '\\'
# define PATH_SEP3 ':'
# define MAX_PATH_LEN 128
# define NO_MULTIPLE_DOTS
# define MAX_EXT_CHARS 3
# define Z_SUFFIX "z"
# define NO_CHOWN
# define casemap(c) tolow(c) /* Force file names to lower case */
# define NO_SYMLINK
# endif
#endif
#ifdef MACOS
# define PATH_SEP ':'
# define DYN_ALLOC
# define PROTO
# define NO_STDIN_FSTAT
# define NO_CHOWN
# define NO_UTIME
# define chmod(file, mode) (0)
# define OPEN(name, flags, mode) open(name, flags)
# define OS_CODE 0x07
# ifdef MPW
# define isatty(fd) ((fd) <= 2)
# endif
#endif
#ifdef __50SERIES /* Prime/PRIMOS */
# define PATH_SEP '>'
# define STDC_HEADERS
# define NO_MEMORY_H
# define NO_UTIME_H
# define NO_UTIME
# define NO_CHOWN
# define NO_STDIN_FSTAT
# define NO_SIZE_CHECK
# define NO_SYMLINK
# define RECORD_IO 1
# define casemap(c) tolow(c) /* Force file names to lower case */
# define put_char(c) put_byte((c) & 0x7F)
# define get_char(c) ascii2pascii(get_byte())
# define OS_CODE 0x0F /* temporary, subject to change */
# ifdef SIGTERM
# undef
SIGTERM /* We don't
want a signal handler for SIGTERM */
# endif
#endif
#if defined(pyr) && !defined(NOMEMCPY) /* Pyramid */
# define NOMEMCPY /* problem with overlapping copies */
#endif
#ifdef TOPS20
# define OS_CODE 0x0a
#endif
#ifndef unix
# define NO_ST_INO /* don't rely on inode numbers */
#endif
/* Common defaults */
#ifndef OS_CODE
# define OS_CODE 0x03 /* assume Unix */
#endif
#ifndef PATH_SEP
# define PATH_SEP '/'
#endif
#ifndef casemap
# define casemap(c) (c)
#endif
#ifndef OPTIONS_VAR
# define OPTIONS_VAR "GZIP"
#endif
#ifndef Z_SUFFIX
# define Z_SUFFIX ".gz"
#endif
#ifdef MAX_EXT_CHARS
# define MAX_SUFFIX MAX_EXT_CHARS
#else
# define MAX_SUFFIX 30
#endif
#ifndef MAKE_LEGAL_NAME
# ifdef NO_MULTIPLE_DOTS
# define MAKE_LEGAL_NAME(name) make_simple_name(name)
# else
# define MAKE_LEGAL_NAME(name)
# endif
#endif
#ifndef MIN_PART
# define MIN_PART 3
/* keep at least MIN_PART chars between dots in a file name. */
#endif
#ifndef EXPAND
# define EXPAND(argc,argv)
#endif
#ifndef RECORD_IO
# define RECORD_IO 0
#endif
#ifndef SET_BINARY_MODE
# define SET_BINARY_MODE(fd)
#endif
#ifndef OPEN
# define OPEN(name, flags, mode) open(name, flags, mode)
#endif
#ifndef get_char
# define get_char() get_byte()
#endif
#ifndef put_char
# define put_char(c) put_byte(c)
#endif
//这是打分的perl脚本
#########################################
# Globals specific to test cases
#########################################
@optional = ("Global List");
$numtestcases = 8;
@testcasetopic = ("Memory Leak", "Footer Payload Overflow", "Footer
Payload Overflow", "Memory Leak", "Freeing Unallocated Block", "Header
Overwrite", "Freeing Unallocated Block", "Global List");
@testcaseweight = (0.10, 0.15, 0.15, 0.15, 0.15, 0.15, 0.15, 0);
# Weights for error, filename/linenum, and correct error message
@individualweight[0] = [1, 0, 0];
@individualweight[1] = [.4, .2, .4];
@individualweight[2] = [.4, .2, .4];
@individualweight[3] = [1, 0, 0]; # possible extra
@individualweight[4] = [1, 0, 0]; # possible extra
@individualweight[5] = [.6, 0, .4];
@individualweight[6] = [1, 0, 0]; # possible extra
@individualweight[7] = [.6, .2, .2];
@iserror = (0, 1, 1, 0, 1, 1, 1, 1); # only really needed for first set
@checkstrings0 = ("Size: 0", "", "", "Size: 6", "", "", "", "Caught errors");
# to check for correct filename/line number
$drivername = "driver.c";
@checkstrings1line1 = ("", "line 21", "line 28", "", "line 43", "line 47", "line 54", "line 59");
@checkstrings1line2 = ("", "line 23", "line 30", "", "", "line 49", "");
# to check for correct error
@checkstrings2a = ("", "Ending edge of the payload has been
overwritten.", "Ending edge of the payload has been overwritten.",
"line 34", "Attempting to free an unallocated block.", "Starting edge
of the payload has been overwritten.", "Attempting to free an
unallocated block.", "Ending edge of the payload has been
overwritten.");
@checkstrings2b = ("", "", "", "", "", "Header has been corrupted.", "");
#################################
$numcriteria = 4;
@criteria = ("Error Recognition", "Best Error Message", "Filename/Line Number", "Memory Leak Analysis (Bonus)");
#################################
# Grader program
#################################
for($i = 0; $i < $numcriteria; $i++) {
$criteriagrade[$i] = 0;
$criteriamax[$i] = 0;
}
foreach $topic (@testcasetopic) {
$topicgrade{$topic} = 0;
$topicmax{$topic} = 0;
}
for($i = 0; $i < $numtestcases; $i++) {
$testcasegrade[$i] = 0;
}
print("\nTest #\t\tError?\tLocation\tReason\n");
for ($i = 1; $i <= $numtestcases; $i++) {
$topic = $testcasetopic[$i - 1];
$bonus = 0;
print("$i (", int($testcaseweight[$i - 1] * 1000 + 0.5) / 10, "%");
if (grep {$topic eq $_} @optional) {
$bonus = 1;
print(" Bonus");
}
print("):\t");
$output = `./debugmalloc -t $i`;
if ($output =~ /Error:/i) {
$result = ($iserror[$i - 1] == 1)?1:0;
}
else {
$result = ($iserror[$i - 1] == 0)?1:0;
}
if ($result == 1) {
$match = $checkstrings0[$i - 1];
if ($match ne "") {
$result = ($output =~ /$match/i)?1:0;
}
}
$criteriagrade[0] += $result * $testcaseweight[$i - 1] * $individualweight[$i-1][0];
$criteriamax[0] += $bonus?0:($testcaseweight[$i - 1] * $individualweight[$i-1][0]);
$topicgrade{$topic} += $result;
$topicmax{$topic} += $bonus?0:1;
$testcasegrade[$i - 1] += $result * $individualweight[$i-1][0];
print("$result\t");
# Check for correct filename/line number
$match1 = $checkstrings1line1[$i - 1];
$match2 = $checkstrings1line2[$i - 1];
if ($match1 ne "") {
$result = 0;
if ($output =~ /$match1/i) {
$result += ($output =~ /$drivername/i)?1:0;
}
if ($match2 ne "") {
if ($output =~ /$match2/i) {
$result += ($output =~ /$drivername/i)?1:0;
}
$result *= 0.5;
}
print("$result\t");
$criteriagrade[2] += $result * $testcaseweight[$i - 1] * $individualweight[$i-1][1];
$criteriamax[2] += $bonus?0:($testcaseweight[$i - 1] * $individualweight[$i-1][1]);
$topicgrade{$topic} += $result;
$topicmax{$topic} += $bonus?0:1;
$testcasegrade[$i - 1] += $result * $individualweight[$i-1][1];
}
else {
print(".\t");
}
# Check for correct reason for error
$match1 = $checkstrings2a[$i - 1];
$match2 = $checkstrings2b[$i - 1];
if ($match1 ne "") {
$result = ($output =~ /$match1/i)?1:0;
if ($result == 0 && $match2 ne "") {
$result = ($output =~ /$match2/i)?1:0;
}
print("\t$result\t");
if ($topic eq "Memory Leak") {
$criteriagrade[3] += $result * $testcaseweight[$i - 1] *
$individualweight[$i-1][2];
$criteriamax[3] += $bonus?0:($testcaseweight[$i - 1] *
$individualweight[$i-1][2]);
}
else {
$criteriagrade[1] += $result * $testcaseweight[$i - 1] *
$individualweight[$i-1][2];
$criteriamax[1] += $bonus?0:($testcaseweight[$i - 1] *
$individualweight[$i-1][2]);
}
$topicgrade{$topic} += $result;
$topicmax{$topic} += $bonus?0:1;
$testcasegrade[$i - 1] += $result * $individualweight[$i-1][2];
}
else {
print("\t.\t");
}
print("\n");
}
print("------------\n");
# Print out results by topic
foreach $topic (keys(%topicgrade)) {
print("$topic: \t$topicgrade{$topic}/$topicmax{$topic}\n");
}
print("------------\n");
# Print out results by criteria
for ($i = 0; $i < $numcriteria; $i++) {
if ($criteriamax[$i] != 0) {
$currgrade = $criteriagrade[$i]/$criteriamax[$i];
$currgrade = int($currgrade * 1000 + .5) / 10;
print("$criteria[$i]: \t", $currgrade, "%\n");
}
else {
print("$criteria[$i]: \t N/A\n");
}
}
print("------------\n");
$totalgrade = 0;
for($i = 0; $i < $numtestcases; $i++) {
$totalgrade += $testcasegrade[$i] * $testcaseweight[$i];
}
$totalgrade = int($totalgrade * 1000 + .5) / 10;
print("Total: $totalgrade%\n\n");
//来看看自己的分数吧
编译好的程序取名为debugmalloc:
Test
# Error?
Location Reason
1
(10%):
1
.
.
2
(15%):
1
1
1
3
(15%):
1
1
1
4
(15%):
1
.
1
5
(15%):
1
1
1
6
(15%):
1
1
1
7
(15%):
1
1
1
8 (0% Bonus):
1
1
1
------------
Header Overwrite: 3/3
Freeing Unallocated Block: 6/6
Footer Payload Overflow: 6/6
Memory Leak: 3/3
Global List: 3/0
------------
Error Recognition: 100%
Best Error Message: 100%
Filename/Line Number: 100%
Memory Leak Analysis (Bonus): N/A
------------
Total: 100%
|