← Back to branch summary

~ubuntu-branches/ubuntu/raring/reprepro/raring

« back to all changes in this revision

Viewing changes to names.c

  • Committer: Bazaar Package Importer
  • Author(s): Bernhard R. Link
  • Date: 2011-05-05 16:34:23 UTC
  • mfrom: (21.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110505163423-x49kbdijyoubai4x
Tags: 4.6.0-1
* new release
- general cleanup
- new FilterSrcList
* increase Standards-Version, no changes needed

Show diffs side-by-side

added added

removed removed

Lines of Context:
names.c
28
28
#include "strlist.h"
29
29
#include "names.h"
30
30
 
31
 
char *calc_addsuffix(const char *str1,const char *str2) {
32
 
        return mprintf("%s.%s",str1,str2);
33
 
}
34
 
 
35
 
char *calc_dirconcat(const char *str1,const char *str2) {
36
 
        return mprintf("%s/%s",str1,str2);
37
 
}
38
 
 
39
 
char *calc_dirconcat3(const char *str1,const char *str2,const char *str3) {
40
 
        return mprintf("%s/%s/%s",str1,str2,str3);
 
31
char *calc_addsuffix(const char *str1, const char *str2) {
 
32
        return mprintf("%s.%s", str1, str2);
 
33
}
 
34
 
 
35
char *calc_dirconcat(const char *str1, const char *str2) {
 
36
        return mprintf("%s/%s", str1, str2);
 
37
}
 
38
 
 
39
char *calc_dirconcat3(const char *str1, const char *str2, const char *str3) {
 
40
        return mprintf("%s/%s/%s", str1, str2, str3);
41
41
}
42
42
 
43
43
/* Create a strlist consisting out of calc_dirconcat'ed entries of the old */
46
46
        retvalue r;
47
47
        int i;
48
48
 
49
 
        assert(directory != NULL && basefilenames != NULL && files != NULL );
 
49
        assert (directory != NULL && basefilenames != NULL && files != NULL);
50
50
 
51
 
        r = strlist_init_n(basefilenames->count,files);
52
 
        if( RET_WAS_ERROR(r) )
 
51
        r = strlist_init_n(basefilenames->count, files);
 
52
        if (RET_WAS_ERROR(r))
53
53
                return r;
54
54
 
55
55
        r = RET_NOTHING;
56
 
        for( i = 0 ; i < basefilenames->count ; i++ ) {
 
56
        for (i = 0 ; i < basefilenames->count ; i++) {
57
57
                char *file;
58
58
 
59
59
                file = calc_dirconcat(directory, basefilenames->values[i]);
60
 
                if( file == NULL ) {
 
60
                if (FAILEDTOALLOC(file)) {
61
61
                        strlist_done(files);
62
62
                        return RET_ERROR_OOM;
63
63
                }
64
 
                r = strlist_add(files,file);
65
 
                if( RET_WAS_ERROR(r) ) {
 
64
                r = strlist_add(files, file);
 
65
                if (RET_WAS_ERROR(r)) {
66
66
                        strlist_done(files);
67
67
                        return r;
68
68
                }
74
74
retvalue calc_inplacedirconcats(const char *directory, struct strlist *files) {
75
75
        int i;
76
76
 
77
 
        assert(directory != NULL && files != NULL );
78
 
        for( i = 0 ; i < files->count ; i++ ) {
 
77
        assert (directory != NULL && files != NULL );
 
78
        for (i = 0 ; i < files->count ; i++) {
79
79
                char *file;
80
80
 
81
81
                file = calc_dirconcat(directory, files->values[i]);
82
 
                if( file == NULL )
 
82
                if (FAILEDTOALLOC(file))
83
83
                        return RET_ERROR_OOM;
84
84
                free(files->values[i]);
85
85
                files->values[i] = file;
91
91
        const char *n = *version;
92
92
        bool hadepoch = epochsuppressed;
93
93
 
94
 
        if( *n < '0' || *n > '9' ) {
95
 
                if( (*n < 'a' || *n > 'z') && (*n < 'A' || *n > 'Z') )
 
94
        if (*n < '0' || *n > '9') {
 
95
                if ((*n < 'a' || *n > 'z') && (*n < 'A' || *n > 'Z'))
96
96
                        return;
97
97
        } else
98
98
                n++;
99
 
        while( *n >= '0' && *n <= '9' )
 
99
        while (*n >= '0' && *n <= '9')
100
100
                n++;
101
 
        if( *n == ':' ) {
 
101
        if (*n == ':') {
102
102
                hadepoch = true;
103
103
                n++;
104
104
        }
105
 
        while( ( *n >= '0' && *n <= '9' ) || ( *n >= 'a' && *n <= 'z')
106
 
                        || ( *n >= 'A' && *n <= 'Z' ) || *n == '.' || *n == '~'
107
 
                        || *n == '-' || *n == '+' || (hadepoch && *n == ':') )
 
105
        while ((*n >= '0' && *n <= '9') || (*n >= 'a' && *n <= 'z')
 
106
                        || (*n >= 'A' && *n <= 'Z') || *n == '.' || *n == '~'
 
107
                        || *n == '-' || *n == '+' || (hadepoch && *n == ':'))
108
108
                n++;
109
109
        *version = n;
110
110
}
111
111
 
112
 
char *calc_trackreferee(const char *codename,const char *sourcename,const char *sourceversion) {
113
 
        return  mprintf("%s %s %s",codename,sourcename,sourceversion);
 
112
char *calc_trackreferee(const char *codename, const char *sourcename, const char *sourceversion) {
 
113
        return  mprintf("%s %s %s", codename, sourcename, sourceversion);
114
114
}
115
115
 
116
 
char *calc_changes_basename(const char *name,const char *version,const struct strlist *architectures) {
 
116
char *calc_changes_basename(const char *name, const char *version, const struct strlist *architectures) {
117
117
        size_t name_l, version_l, l;
118
118
        int i;
119
 
        char *n,*p;
 
119
        char *n, *p;
120
120
 
121
121
        name_l = strlen(name);
122
122
        version_l = strlen(version);
123
123
        l = name_l + version_l + sizeof("__.changes");
124
124
 
125
 
        for( i = 0 ; i < architectures->count ; i++ ) {
 
125
        for (i = 0 ; i < architectures->count ; i++) {
126
126
                l += strlen(architectures->values[i]);
127
 
                if( i != 0 )
 
127
                if (i != 0)
128
128
                        l++;
129
129
        }
130
130
        n = malloc(l);
131
 
        if( n == NULL )
 
131
        if (FAILEDTOALLOC(n))
132
132
                return n;
133
133
        p = n;
134
134
        memcpy(p, name, name_l); p+=name_l;
135
135
        *(p++) = '_';
136
136
        memcpy(p, version, version_l); p+=version_l;
137
137
        *(p++) = '_';
138
 
        for( i = 0 ; i < architectures->count ; i++ ) {
 
138
        for (i = 0 ; i < architectures->count ; i++) {
139
139
                size_t a_l = strlen(architectures->values[i]);
140
 
                if( i != 0 )
 
140
                if (i != 0)
141
141
                        *(p++) = '+';
142
 
                assert( (size_t)((p+a_l)-n) < l );
 
142
                assert ((size_t)((p+a_l)-n) < l);
143
143
                memcpy(p, architectures->values[i], a_l);
144
144
                p += a_l;
145
145
        }
146
 
        assert( (size_t)(p-n) < l-8 );
147
 
        memcpy(p, ".changes", 9 ); p += 9;
148
 
        assert( *(p-1) == '\0' );
149
 
        assert( (size_t)(p-n) == l );
 
146
        assert ((size_t)(p-n) < l-8);
 
147
        memcpy(p, ".changes", 9); p += 9;
 
148
        assert (*(p-1) == '\0');
 
149
        assert ((size_t)(p-n) == l);
150
150
        return n;
151
151
}