Run Nindent on com32/lib/syslinux/shuffle.c

Automatically reformat com32/lib/syslinux/shuffle.c using Nindent.

Do this for all files except HDT, gPXE and externally maintained
libraries (zlib, tinyjpeg, libpng).

Signed-off-by: H. Peter Anvin <hpa@zytor.com>

diff --git a/com32/lib/syslinux/shuffle.c b/com32/lib/syslinux/shuffle.c
index 6c33d0a..6b5a601 100644 (file)
--- a/com32/lib/syslinux/shuffle.c
+++ b/com32/lib/syslinux/shuffle.c
@@ -60,19 +60,19 @@
 #endif
 
 struct shuffle_descriptor {
-  uint32_t dst, src, len;
+    uint32_t dst, src, len;
 };
 
 static int shuffler_size;
 
 static void __constructor __syslinux_get_shuffer_size(void)
 {
-  static com32sys_t reg;
+    static com32sys_t reg;
 
-  reg.eax.w[0] = 0x0023;
-  __intcall(0x22, &reg, &reg);
+    reg.eax.w[0] = 0x0023;
+    __intcall(0x22, &reg, &reg);
 
-  shuffler_size = (reg.eflags.l & EFLAGS_CF) ? 2048 : reg.ecx.w[0];
+    shuffler_size = (reg.eflags.l & EFLAGS_CF) ? 2048 : reg.ecx.w[0];
 }
 
 /*
@@ -86,187 +86,190 @@ int syslinux_do_shuffle(struct syslinux_movelist *fraglist,
                        addr_t entry_point, addr_t entry_type,
                        uint16_t bootflags)
 {
-  int rv = -1;
-  struct syslinux_movelist *moves = NULL, *mp;
-  struct syslinux_memmap *rxmap = NULL, *ml;
-  struct shuffle_descriptor *dp, *dbuf;
-  int np;
-  int desc_blocks, need_blocks;
-  int need_ptrs;
-  addr_t desczone, descfree, descaddr, descoffs;
-  int nmoves, nzero;
-  com32sys_t ireg;
-
-  descaddr = 0;
-  dp = dbuf = NULL;
-
-  /* Count the number of zero operations */
-  nzero = 0;
-  for (ml = memmap; ml->type != SMT_END; ml = ml->next) {
-    if (ml->type == SMT_ZERO)
-      nzero++;
-  }
-
-  /* Find the largest contiguous region unused by input *and* output;
-     this is where we put the move descriptor list and safe area */
-
-  rxmap = syslinux_dup_memmap(memmap);
-  if (!rxmap)
-    goto bail;
-  /* Avoid using the low 1 MB for the shuffle area -- this avoids
-     possible interference with the real mode code or stack */
-  if (syslinux_add_memmap(&rxmap, 0, 1024*1024, SMT_RESERVED))
-    goto bail;
-  for (mp = fraglist; mp; mp = mp->next) {
-    if (syslinux_add_memmap(&rxmap, mp->src, mp->len, SMT_ALLOC) ||
-       syslinux_add_memmap(&rxmap, mp->dst, mp->len, SMT_ALLOC))
-      goto bail;
-  }
-  if (syslinux_memmap_largest(rxmap, SMT_FREE, &desczone, &descfree))
-    goto bail;
-
-  syslinux_free_memmap(rxmap);
-
-  dprintf("desczone = 0x%08x, descfree = 0x%08x\n", desczone, descfree);
-
-  rxmap = syslinux_dup_memmap(memmap);
-  if (!rxmap)
-    goto bail;
-
-  desc_blocks = (nzero+DESC_BLOCK_SIZE-1)/DESC_BLOCK_SIZE;
-  for (;;) {
-    /* We want (desc_blocks) allocation blocks, plus the terminating
-       descriptor, plus the shuffler safe area. */
-    addr_t descmem = desc_blocks*
-      sizeof(struct shuffle_descriptor)*DESC_BLOCK_SIZE
-      + sizeof(struct shuffle_descriptor) + shuffler_size;
-
-    descaddr = (desczone + descfree - descmem) & ~3;
-
-    if (descaddr < desczone)
-      goto bail;               /* No memory block large enough */
-
-    /* Mark memory used by shuffle descriptors as reserved */
-    if (syslinux_add_memmap(&rxmap, descaddr, descmem, SMT_RESERVED))
-      goto bail;
+    int rv = -1;
+    struct syslinux_movelist *moves = NULL, *mp;
+    struct syslinux_memmap *rxmap = NULL, *ml;
+    struct shuffle_descriptor *dp, *dbuf;
+    int np;
+    int desc_blocks, need_blocks;
+    int need_ptrs;
+    addr_t desczone, descfree, descaddr, descoffs;
+    int nmoves, nzero;
+    com32sys_t ireg;
+
+    descaddr = 0;
+    dp = dbuf = NULL;
+
+    /* Count the number of zero operations */
+    nzero = 0;
+    for (ml = memmap; ml->type != SMT_END; ml = ml->next) {
+       if (ml->type == SMT_ZERO)
+           nzero++;
+    }
+
+    /* Find the largest contiguous region unused by input *and* output;
+       this is where we put the move descriptor list and safe area */
+
+    rxmap = syslinux_dup_memmap(memmap);
+    if (!rxmap)
+       goto bail;
+    /* Avoid using the low 1 MB for the shuffle area -- this avoids
+       possible interference with the real mode code or stack */
+    if (syslinux_add_memmap(&rxmap, 0, 1024 * 1024, SMT_RESERVED))
+       goto bail;
+    for (mp = fraglist; mp; mp = mp->next) {
+       if (syslinux_add_memmap(&rxmap, mp->src, mp->len, SMT_ALLOC) ||
+           syslinux_add_memmap(&rxmap, mp->dst, mp->len, SMT_ALLOC))
+           goto bail;
+    }
+    if (syslinux_memmap_largest(rxmap, SMT_FREE, &desczone, &descfree))
+       goto bail;
+
+    syslinux_free_memmap(rxmap);
+
+    dprintf("desczone = 0x%08x, descfree = 0x%08x\n", desczone, descfree);
+
+    rxmap = syslinux_dup_memmap(memmap);
+    if (!rxmap)
+       goto bail;
+
+    desc_blocks = (nzero + DESC_BLOCK_SIZE - 1) / DESC_BLOCK_SIZE;
+    for (;;) {
+       /* We want (desc_blocks) allocation blocks, plus the terminating
+          descriptor, plus the shuffler safe area. */
+       addr_t descmem = desc_blocks *
+           sizeof(struct shuffle_descriptor) * DESC_BLOCK_SIZE
+           + sizeof(struct shuffle_descriptor) + shuffler_size;
+
+       descaddr = (desczone + descfree - descmem) & ~3;
+
+       if (descaddr < desczone)
+           goto bail;          /* No memory block large enough */
+
+       /* Mark memory used by shuffle descriptors as reserved */
+       if (syslinux_add_memmap(&rxmap, descaddr, descmem, SMT_RESERVED))
+           goto bail;
 
 #if DEBUG > 1
-    syslinux_dump_movelist(stdout, fraglist);
+       syslinux_dump_movelist(stdout, fraglist);
 #endif
 
-    if (syslinux_compute_movelist(&moves, fraglist, rxmap))
-      goto bail;
+       if (syslinux_compute_movelist(&moves, fraglist, rxmap))
+           goto bail;
 
-    nmoves = 0;
-    for (mp = moves; mp; mp = mp->next)
-      nmoves++;
+       nmoves = 0;
+       for (mp = moves; mp; mp = mp->next)
+           nmoves++;
 
-    need_blocks = (nmoves+nzero+DESC_BLOCK_SIZE-1)/DESC_BLOCK_SIZE;
+       need_blocks = (nmoves + nzero + DESC_BLOCK_SIZE - 1) / DESC_BLOCK_SIZE;
 
-    if (desc_blocks >= need_blocks)
-      break;                   /* Sufficient memory, yay */
+       if (desc_blocks >= need_blocks)
+           break;              /* Sufficient memory, yay */
 
-    desc_blocks = need_blocks; /* Try again... */
-  }
+       desc_blocks = need_blocks;      /* Try again... */
+    }
 
 #if DEBUG > 1
-  dprintf("Final movelist:\n");
-  syslinux_dump_movelist(stdout, moves);
+    dprintf("Final movelist:\n");
+    syslinux_dump_movelist(stdout, moves);
 #endif
 
-  syslinux_free_memmap(rxmap);
-  rxmap = NULL;
+    syslinux_free_memmap(rxmap);
+    rxmap = NULL;
 
-  need_ptrs = nmoves+nzero+1;
-  dbuf = malloc(need_ptrs*sizeof(struct shuffle_descriptor));
-  if (!dbuf)
-    goto bail;
+    need_ptrs = nmoves + nzero + 1;
+    dbuf = malloc(need_ptrs * sizeof(struct shuffle_descriptor));
+    if (!dbuf)
+       goto bail;
 
-  descoffs = descaddr - (addr_t)dbuf;
+    descoffs = descaddr - (addr_t) dbuf;
 
 #if DEBUG
-  dprintf("nmoves = %d, nzero = %d, dbuf = %p, offs = 0x%08x\n",
-         nmoves, nzero, dbuf, descoffs);
+    dprintf("nmoves = %d, nzero = %d, dbuf = %p, offs = 0x%08x\n",
+           nmoves, nzero, dbuf, descoffs);
 #endif
 
-  /* Copy the move sequence into the descriptor buffer */
-  np = 0;
-  dp = dbuf;
-  for (mp = moves; mp; mp = mp->next) {
-    dp->dst = mp->dst;
-    dp->src = mp->src;
-    dp->len = mp->len;
-    dprintf2("[ %08x %08x %08x ]\n", dp->dst, dp->src, dp->len);
-    dp++; np++;
-  }
-
-  /* Copy bzero operations into the descriptor buffer */
-  for (ml = memmap; ml->type != SMT_END; ml = ml->next) {
-    if (ml->type == SMT_ZERO) {
-      dp->dst = ml->start;
-      dp->src = (addr_t)-1;    /* bzero region */
-      dp->len = ml->next->start - ml->start;
-      dprintf2("[ %08x %08x %08x ]\n", dp->dst, dp->src, dp->len);
-      dp++; np++;
+    /* Copy the move sequence into the descriptor buffer */
+    np = 0;
+    dp = dbuf;
+    for (mp = moves; mp; mp = mp->next) {
+       dp->dst = mp->dst;
+       dp->src = mp->src;
+       dp->len = mp->len;
+       dprintf2("[ %08x %08x %08x ]\n", dp->dst, dp->src, dp->len);
+       dp++;
+       np++;
     }
-  }
-
-  /* Finally, record the termination entry */
-  dp->dst = entry_point;
-  dp->src = entry_type;
-  dp->len = 0;
-  dp++; np++;
-
-  if (np != need_ptrs) {
-    dprintf("!!! np = %d : nmoves = %d, nzero = %d, desc_blocks = %d\n",
-           np, nmoves, nzero, desc_blocks);
-  }
-
-  rv = 0;
-
- bail:
-  /* This is safe only because free() doesn't use the bounce buffer!!!! */
-  if (moves)
-    syslinux_free_movelist(moves);
-  if (rxmap)
-    syslinux_free_memmap(rxmap);
 
-  if (rv)
-    return rv;
+    /* Copy bzero operations into the descriptor buffer */
+    for (ml = memmap; ml->type != SMT_END; ml = ml->next) {
+       if (ml->type == SMT_ZERO) {
+           dp->dst = ml->start;
+           dp->src = (addr_t) - 1;     /* bzero region */
+           dp->len = ml->next->start - ml->start;
+           dprintf2("[ %08x %08x %08x ]\n", dp->dst, dp->src, dp->len);
+           dp++;
+           np++;
+       }
+    }
+
+    /* Finally, record the termination entry */
+    dp->dst = entry_point;
+    dp->src = entry_type;
+    dp->len = 0;
+    dp++;
+    np++;
+
+    if (np != need_ptrs) {
+       dprintf("!!! np = %d : nmoves = %d, nzero = %d, desc_blocks = %d\n",
+               np, nmoves, nzero, desc_blocks);
+    }
 
-  /* Actually do it... */
-  memset(&ireg, 0, sizeof ireg);
-  ireg.edi.l = descaddr;
-  ireg.esi.l = (addr_t)dbuf;
-  ireg.ecx.l = (addr_t)dp-(addr_t)dbuf;
-  ireg.edx.w[0] = bootflags;
-  ireg.eax.w[0] = 0x0024;
-  __intcall(0x22, &ireg, NULL);
+    rv = 0;
 
-  return -1;                   /* Shouldn't have returned! */
+bail:
+    /* This is safe only because free() doesn't use the bounce buffer!!!! */
+    if (moves)
+       syslinux_free_movelist(moves);
+    if (rxmap)
+       syslinux_free_memmap(rxmap);
+
+    if (rv)
+       return rv;
+
+    /* Actually do it... */
+    memset(&ireg, 0, sizeof ireg);
+    ireg.edi.l = descaddr;
+    ireg.esi.l = (addr_t) dbuf;
+    ireg.ecx.l = (addr_t) dp - (addr_t) dbuf;
+    ireg.edx.w[0] = bootflags;
+    ireg.eax.w[0] = 0x0024;
+    __intcall(0x22, &ireg, NULL);
+
+    return -1;                 /* Shouldn't have returned! */
 }
 
 /*
  * Common helper routine: takes a memory map and blots out the
  * zones which are used in the destination of a fraglist
  */
-struct syslinux_memmap *
-syslinux_target_memmap(struct syslinux_movelist *fraglist,
-                      struct syslinux_memmap *memmap)
+struct syslinux_memmap *syslinux_target_memmap(struct syslinux_movelist
+                                              *fraglist,
+                                              struct syslinux_memmap *memmap)
 {
-  struct syslinux_memmap *tmap;
-  struct syslinux_movelist *mp;
-
-  tmap = syslinux_dup_memmap(memmap);
-  if (!tmap)
-    return NULL;
-
-  for (mp = fraglist; mp; mp = mp->next) {
-    if (syslinux_add_memmap(&tmap, mp->dst, mp->len, SMT_ALLOC)) {
-      syslinux_free_memmap(tmap);
-      return NULL;
+    struct syslinux_memmap *tmap;
+    struct syslinux_movelist *mp;
+
+    tmap = syslinux_dup_memmap(memmap);
+    if (!tmap)
+       return NULL;
+
+    for (mp = fraglist; mp; mp = mp->next) {
+       if (syslinux_add_memmap(&tmap, mp->dst, mp->len, SMT_ALLOC)) {
+           syslinux_free_memmap(tmap);
+           return NULL;
+       }
     }
-  }
 
-  return tmap;
+    return tmap;
 }