The C/C++ Parser Generator (v. 2.x)-- Intro & Example 1 (ToCamelCase)

    ok = ( ( (n == 1) ||  skip_str("_") ) && copy_toupper(1) ) || copy_n(1);

// main.cpp -- skeleton created by new.main

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include "parser.h"

#include "common/parser.cpp" // don't need a lib

void dbg(){} // for a non-moving breakpoint

#define streq(a, b) (strcmp(a, b) == 0)
#define VERSION_MAJOR 1
#define VERSION_MINOR 0

int usage(int errcode);
int print_version();

// parser functions all do 'return obj.state = <T or F>;'
// so that both the internal state and the returned values
// are the same.  Here's a typical parser_t function
// prototype, though in C/C++ there's no restriction to having
// parameters except for parsers and certain cases such as 
// do_until(test_func, action_funct), and the like.

bool to_camel();

int main(int argc, char** argv)
{
  dbg();
  if(argc < 2) return usage(1);
  if(streq(argv[1], "--help")) return usage(0);

  // we need a constant array of chars, null terminated for the
  // input buffer.
  
  cstr inbuf = argv[1];
  
  // This could just be the size of the input string or file

#define INLEN (strlen(inbuf))
  
  // The output buffer is not resizable due to the added
  // complexity and risks invovled in a tracking a moving 
  // buffer if/when it resizes.  So we anticipate a worst
  // case, which we'll "catch" if an error occurs.

#define OUTLEN ((INLEN * 2) + 256)

  // We need a variable array of chars for the output buffer.
  vstr outbuf = (vstr)malloc(OUTLEN);
  
  // We need one global obj, but we can't use the name 'obj' anywhere
  // except in any new parser_t functions we may create.
  
  PARSER_OBJ o;

  // Set up the globals using (in this case) an OBJ created on our
  // stack.  (It's safe here at the top level.)

  parser_init(&o, inbuf, INLEN, outbuf, OUTLEN);
  
  bool ok = true;

  // Example of C-like syntax for parser funcs.
  
  ok =
    parse()         // when true, we're done
    ||              // OR (else)
    parse_error()  // prints out from last saved UPDATE_ERRMSG() pointer
    ;

  if(ok)
    printf("%s\n", obj.outbuf);
  
  free(outbuf);
  dbg();
  // add routines here
  return 0;
}

int usage(int errcode)
{
#include "common/to_camel_str.dat"
  fprintf( errcode == 0 ? stdout : stderr, "%s", usage_str);
  return errcode;
}

// The global 'obj' macro now can access the fields of the
// PARSER_OBJ we created above, so no parameters are req'd
// for most of the parser functions.

bool parse()
{

  // set a watchpoint at 'obj' and 'ok' to see what it is doing
  // internally as well as externally.
  
  bool ok;
  
  static cstr errmsg = "Unknown error in 'parse()'";
  
  // For error messages we may want to use the build-in ERRMSG() functions.
  // which must be 'static' so they will not crash when the strings are
  // displayed at the top level.  Locals are all savved on the stack and
  // the stack at this level will not exist when the program exits.
  
  SAVE_STATIC_ERRMSG(errmsg);

  // This is redundant in this case but if this was a loop this would update
  // the pointers to the input buffer so we could get an accurate line count
  // and see the position where the parse job failed.
  
  UPDATE_STATIC_ERRMSG();

  // So with no more ado ...
  ok = to_camel();
  
  if(ok)
    RESTORE_STATIC_ERRMSG();
  
  return obj.state = ok;
}


// converts "this_kind_of_string" to "ThisKindOfString"
bool to_camel()
{
  // typical header:
  bool ok = true;

  // Body:
  //////////////////////
  int n = 0;
  
  while(not_eoi() && ok)
  {
    
    UPDATE_STATIC_ERRMSG(); // update error position each pass
    n++;
    
    ok =
      (
        (
          (n == 1)
          ||
          skip_str("_")
        )
        &&
        copy_toupper(1)
      )
      || copy_n(1)
      ;
    
    // The above reads if we can skip an underscore or if n == 1, uppercase
    // the next letter, otherwise, just copy a character and repeat until
    // end of input or until ok = false.

    // to see what happens if we have an error try this.
    
#if 0 // set to 1 to enable the error display test
    if(n == 3)
      ok = obj.state = false;
#endif
    
  } // end of while() loop
  
  //////////////////////

  // typical footer:
  return obj.state = ok; // or not ;-)
}

/* to_camel_str.txt converted with txt2cstr */
const char* usage_str =
    "Usage: input a string like \"this_one\" to convert it to one\n"
    "like \"ThisOne\".\n"
    ;

## Makefile created with makefile creator 'mc2' v 3.2.0

################################################################
## Note: The following section can be put into a 'mc2.def' and 
## modified for automatic override of defaults as needed.
################################################################

################################################################
## Variable Definitions Section

## User Defined Vars

PREFIX = $(HOME)/usr
BUILDDIR := $(PWD)
## The output file name not including path
OUTNAME = MULTI

## The directories for sources, (temp) objects, and binary output(s)
BINDIR = .
SRCDIR = src
OBJDIR = o

## What COMPILE should do.
COMPILE = g++ -c -o
CFLAGS = -Wall -Wno-comment -g3
INCLUDE = -I $(SRCDIR) -I. -I /usr/include

## What LINK should do.
LINK = g++ -o
LDFLAGS = 
LIB = -L/usr/lib -L$(PREFIX)/lib

## MODIFY BELOW THIS LINE WITH GREAT CARE
################################################################
## File Lists Section

## The full path to the output file
MAIN = $(MAIN_FILES)

SRC = \
  src/to-camel.cpp \
  #############

HDR = \
  src/parser.h \
  #############

OBJ = \
  o/to-camel.o \
  #############

MAIN_FILES = \
  ./to-camel \
  #############

################################################################
## Rules Section

all: $(EXT_ALL) $(MAIN) $(HDR) $(SRC)

$(BINDIR)/to-camel: $(OBJDIR)/to-camel.o
	@echo
	@echo "Linking to-camel"
	$(LINK) $(BINDIR)/to-camel $(OBJDIR)/to-camel.o $(LDFLAGS) $(LIB)
	$(POST)

$(OBJDIR)/to-camel.o: $(SRCDIR)/to-camel.cpp $(HDR)
	@echo
	@echo "Compiling to-camel"
	$(COMPILE) $(OBJDIR)/to-camel.o $(SRCDIR)/to-camel.cpp $(CFLAGS) $(INCLUDE)

################################################################
## Additional Targets

update: $(EXT_UPDATE)
	@mc2 -update

# example targets
#mc2-semiclean: $(EXT_SEMICLEAN)
#	@rm -f *~ */*~ */*/*~

#mc2-clean: $(EXT_CLEAN)
#	@rm -f $(MAIN)
#	@rm -f $(OBJ)
#	@rm -f *~ */*~ */*/*~ */*/*/*~
################################################################
## User Defined Targets


semiclean: $(EXT_SEMICLEAN)
	@rm -f $(OBJ)
	@rm -f *~ */*~ */*/*~ */*/*/*~
	@rm -f *.kdevelop.filelist  *.kdevelop.pcs  *.kdevses Doxyfile

strip:
	@strip $(MAIN_FILES)
	@make semiclean

clean: $(EXT_CLEAN)
	@rm -f $(MAIN_FILES)
	@rm -f $(OBJ)
	@rm -f *.kdevelop.pcs *.kdevses
	@rm -f *~ */*~ */*/*~ */*/*/*~ tmp.mak

force: # used to force execution

 
################################################################

# mc2.def template created with Makefile Creator 'mc2'

# sandbox path and other new variables
PREFIX = $(HOME)/usr
BUILDDIR := $(PWD)

OUTNAME = MULTI

SRCDIR = src
OBJDIR = o
BINDIR = .

# what COMPILE should do
COMPILE = g++ -c -o # COMPILE <output_file> ...
 CFLAGS = -Wall -Wno-comment -g3 # debug
# CFLAGS = -Wall -O2 # optimized
INCLUDE = -I $(SRCDIR) -I. -I /usr/include 

# what LINK should do
LINK = g++ -o # LINK <output_file> ...
LDFLAGS = 
LIB = -L/usr/lib -L$(PREFIX)/lib


semiclean: $(EXT_SEMICLEAN)
  @rm -f $(OBJ)
  @rm -f *~ */*~ */*/*~ */*/*/*~
  @rm -f *.kdevelop.filelist  *.kdevelop.pcs  *.kdevses Doxyfile

strip:
  @strip $(MAIN_FILES)
  @make semiclean

clean: $(EXT_CLEAN)
  @rm -f $(MAIN_FILES)
  @rm -f $(OBJ)
  @rm -f *.kdevelop.pcs *.kdevses
  @rm -f *~ */*~ */*/*~ */*/*/*~ tmp.mak
  
force: # used to force execution