[Samsung Galaxy Express GT-I8730 Guides, News, & Di] KINGbabasula:
Here you go:

/* tools/mkbootimg/mkbootimg.c
**
** Copyright 2007, The Android Open Source Project
** Copyright (c) 2012, Code Aurora Forum. All rights reserved.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#include "mincrypt/sha.h"
#include "bootimg.h"

#define ROUND_TO_PAGE(x, y) (((x) + (y)) & (~(y)))

static void *load_file(const char *fn, unsigned *_sz)
{
char *data;
int sz;
int fd;

data = 0;
fd = open(fn, O_RDONLY);
if(fd < 0) return 0;

sz = lseek(fd, 0, SEEK_END);
if(sz < 0) goto oops;

if(lseek(fd, 0, SEEK_SET) != 0) goto oops;

data = (char*) malloc(sz);
if(data == 0) goto oops;

if(read(fd, data, sz) != sz) goto oops;
close(fd);

if(_sz) *_sz = sz;
return data;

oops:
close(fd);
if(data != 0) free(data);
return 0;
}

int usage(void)
{
fprintf(stderr,"usage: mkbootimg\n"
" --kernel <filename>\n"
" --ramdisk <filename>\n"
" [ --ramdisk_offset <offset> ]\n"
" [ -z ] \n"
" [ --second <2ndbootloader-filename> ]\n"
" [ --cmdline <kernel-commandline> ]\n"
" [ --board <boardname> ]\n"
" [ --base <address> ]\n"
" [ --pagesize <pagesize> ]\n"
" -o|--output <filename>\n"
);
return 1;
}

static unsigned char padding[4096] = { 0, };

int write_padding(int fd, unsigned pagesize, unsigned itemsize)
{
unsigned pagemask = pagesize - 1;
unsigned count;

if((itemsize & pagemask) == 0) {
return 0;
}

count = pagesize - (itemsize & pagemask);

if(write(fd, padding, count) != count) {
return -1;
} else {
return 0;
}
}

int parse_log_addr(char *filename)
{
FILE* fp;
char buffer[128];
char data[9];
char *p;
int retValue = 0;
int found =0;

char *subs = "__log_buf";
fp=fopen(filename,"r");

if(fp==NULL)
return -1;
while ((fgets (buffer, 100, fp)) != NULL){
if( (p =strstr(buffer, subs))){
found = 1;
break;
}
}
fclose(fp);

if(!found)
return -1;

memcpy(data,buffer,8);
data[8] = 0;

sscanf(data,"%x",&retValue);

return (retValue - 0xc0000000 +0x200000);
}

int main(int argc, char **argv)
{
boot_img_hdr hdr;

char *system_map = 0;
char *kernel_fn = 0;
void *kernel_data = 0;
char *ramdisk_fn = 0;
void *ramdisk_data = 0;
char *second_fn = 0;
void *second_data = 0;
char *cmdline = "";
char *bootimg = 0;
char *board = "";
unsigned pagesize = 2048;
int fd;
SHA_CTX ctx;
const uint8_t* sha;
unsigned base = 0x10000000;
unsigned ramdisk_offset = 0x02000000;
int compressed_kernel = 0;

argc--;
argv++;

memset(&hdr, 0, sizeof(hdr));

while(argc > 0){
char *arg = argv[0];
char *val = argv[1];
if(argc < 2) {
return usage();
}
argc -= 2;
argv += 2;
if(!strcmp(arg, "--output") || !strcmp(arg, "-o")) {
bootimg = val;
} else if(!strcmp(arg, "--kernel")) {
kernel_fn = val;
} else if(!strcmp(arg, "--systemmap")) {
system_map = val;
} else if(!strcmp(arg, "--ramdisk")) {
ramdisk_fn = val;
} else if(!strcmp(arg, "--second")) {
second_fn = val;
} else if(!strcmp(arg, "--cmdline")) {
cmdline = val;
} else if(!strcmp(arg, "--base")) {
base = strtoul(val, 0, 16);
} else if(!strcmp(arg, "--board")) {
board = val;
} else if(!strcmp(arg,"--pagesize")) {
pagesize = strtoul(val, 0, 10);
if ((pagesize != 2048) && (pagesize != 4096)) {
fprintf(stderr,"error: unsupported page size %d\n", pagesize);
return -1;
}
} else if (!strcmp(arg, "--ramdisk_offset")) {
ramdisk_offset = strtoul(val, 0, 16);
} else if (!strcmp(arg, "-z")) {
compressed_kernel = 1;
argc++;
argv--;
} else {
return usage();
}
}
hdr.page_size = pagesize;

if(bootimg == 0) {
fprintf(stderr,"error: no output filename specified\n");
return usage();
}

if(kernel_fn == 0) {
fprintf(stderr,"error: no kernel image specified\n");
return usage();
}

if(ramdisk_fn == 0) {
fprintf(stderr,"error: no ramdisk image specified\n");
return usage();
}

if(strlen(board) >= BOOT_NAME_SIZE) {
fprintf(stderr,"error: board name too large\n");
return usage();
}

hdr.second_addr = base + 0x00F00000;
hdr.tags_addr = base + 0x00000100;
hdr.ramdisk_addr = base + 0x00000000 + ramdisk_offset;
if(parse_log_addr(system_map) > 0)
{
hdr.log_buf_addr = parse_log_addr(system_map);
hdr.log_buf_magic = RESERVE_LOG_MAGIC;//ML,
}

strcpy((char*)hdr.name, board);

memcpy(hdr.magic, BOOT_MAGIC, BOOT_MAGIC_SIZE);

if(strlen(cmdline) > (BOOT_ARGS_SIZE - 1)) {
fprintf(stderr,"error: kernel commandline too large\n");
return 1;
}
strcpy((char*)hdr.cmdline, cmdline);

kernel_data = load_file(kernel_fn, &hdr.kernel_size);
if(kernel_data == 0) {
fprintf(stderr,"error: could not load kernel '%s'\n", kernel_fn);
return 1;
}

if(!strcmp(ramdisk_fn,"NONE")) {
ramdisk_data = 0;
hdr.ramdisk_size = 0;
} else {
ramdisk_data = load_file(ramdisk_fn, &hdr.ramdisk_size);
if(ramdisk_data == 0) {
fprintf(stderr,"error: could not load ramdisk '%s'\n", ramdisk_fn);
return 1;
}
}

if (compressed_kernel) {
/* put the compressed image after the ramdisk so that the
decompressor may run without having to relocate itself and
the compressed image */
hdr.kernel_addr = hdr.ramdisk_addr +
ROUND_TO_PAGE(hdr.ramdisk_size, (pagesize - 1));
hdr.kernel_addr = (hdr.kernel_addr + 4) & 0xfffffffc;
} else
hdr.kernel_addr = base + 0x00008000;

if(second_fn) {
second_data = load_file(second_fn, &hdr.second_size);
if(second_data == 0) {
fprintf(stderr,"error: could not load secondstage '%s'\n", second_fn);
return 1;
}
}

/* put a hash of the contents in the header so boot images can be
* differentiated based on their first 2k.
*/
SHA_init(&ctx);
SHA_update(&ctx, kernel_data, hdr.kernel_size);
SHA_update(&ctx, &hdr.kernel_size, sizeof(hdr.kernel_size));
SHA_update(&ctx, ramdisk_data, hdr.ramdisk_size);
SHA_update(&ctx, &hdr.ramdisk_size, sizeof(hdr.ramdisk_size));
SHA_update(&ctx, second_data, hdr.second_size);
SHA_update(&ctx, &hdr.second_size, sizeof(hdr.second_size));
sha = SHA_final(&ctx);
memcpy(hdr.id, sha,
SHA_DIGEST_SIZE > sizeof(hdr.id) ? sizeof(hdr.id) : SHA_DIGEST_SIZE);

fd = open(bootimg, O_CREAT | O_TRUNC | O_WRONLY, 0644);
if(fd < 0) {
fprintf(stderr,"error: could not create '%s'\n", bootimg);
return 1;
}

if(write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) goto fail;
if(write_padding(fd, pagesize, sizeof(hdr))) goto fail;

if(write(fd, kernel_data, hdr.kernel_size) != hdr.kernel_size) goto fail;
if(write_padding(fd, pagesize, hdr.kernel_size)) goto fail;

if(write(fd, ramdisk_data, hdr.ramdisk_size) != hdr.ramdisk_size) goto fail;
if(write_padding(fd, pagesize, hdr.ramdisk_size)) goto fail;

if(second_data) {
if(write(fd, second_data, hdr.second_size) != hdr.second_size) goto fail;
if(write_padding(fd, pagesize, hdr.ramdisk_size)) goto fail;
}

return 0;

fail:
unlink(bootimg);
close(fd);
fprintf(stderr,"error: failed writing '%s': %s\n", bootimg,
strerror(errno));
return 1;
}

The build is finally uploaded :highfive: goo.im/devs/KINGbabasula/GalaxyExpress/cm-10.2 . It will say the files doesn't exist so please wait some time