char * addstringchar(char * str, char * chr)
{
}


void increaseindent(char * var_indent)
{
    char * var_indent = addstringchar(var_indent, " ");
    char * var_indent = addstringchar(var_indent, " ");
    char * var_indent = addstringchar(var_indent, " ");
    char * var_indent = addstringchar(var_indent, " ");
    return var_indent;
}

void lexident()
{
    char * var_word = "";
    while (1)
    {
        char * var_char = peek();
        char * var_isbeforea = lt(var_char, "a");
        if (var_isbeforea)
        {
            break;
        }
        char * var_isafterz = lt("z", var_char);
        if (var_isafterz)
        {
            break;
        }
        char * var_word = addstringchar(var_word, var_char);
        skip();
    }
    return var_word;
}

void parseconststring()
{
    skipchar(var_quote);
    emit(var_quote);
    while (1)
    {
        char * var_char = peek();
        char * var_iseof = eq(var_char, var_eof);
        if (var_iseof)
        {
            break;
        }
        char * var_isquote = eq(var_char, var_quote);
        if (var_isquote)
        {
            break;
        }
        emit(var_char);
        skip();
    }
    skipchar(var_quote);
    emit(var_quote);
}

void parseexprvarref()
{
    char * var_varname = lexident();
    emit("var_");
    emit(var_varname);
}

void parseexprcall()
{
    char * var_funcname = lexident();
    emit(var_funcname);
    emit("(");
    char * var_first = "1";
    while (1)
    {
        char * var_char = peek();
        char * var_isspace = eq(var_char, " ");
        char * var_isnotspace = not(var_isspace);
        if (var_isnotspace)
        {
            break;
        }
        skip();
        char * var_isfirst = eq(var_first, "1");
        char * var_isnotfirst = not(var_isfirst);
        if (var_isnotfirst)
        {
            emit(", ");
        }
        char * var_char = peek();
        char * var_isquote = eq(var_char, var_quote);
        char * var_isnotquote = not(var_isquote);
        if (var_isquote)
        {
            parseconststring();
        }
        if (var_isnotquote)
        {
            parseexprvarref();
        }
        char * var_first = "0";
    }
    emit(")");
}

void parsestatset(char * var_indent)
{
    skipchar(" ");
    char * var_var = lexident();
    skipchar(" ");
    emit(var_indent);
    emit("char * var_");
    emit(var_var);
    emit(" = ");
    parseconststring();
    emit(";");
    emit(var_eol);
    skipchar(var_eol);
}

void parsestatcalc(char * var_indent)
{
    skipchar(" ");
    char * var_var = lexident();
    skipchar(" ");
    emit(var_indent);
    emit("char * var_");
    emit(var_var);
    emit(" = ");
    parseexprcall();
    emit(";");
    emit(var_eol);
    skipchar(var_eol);
}

void parsestatif(char * var_indent)
{
    skipchar(" ");
    emit(var_indent);
    emit("if (");
    parseexprvarref();
    emit(")\n");
    emit(var_indent);
    emit("{\n");
    skipchar(var_eol);
    char * var_indentt = increaseindent(var_indent);
    parseblock(var_indentt);
    emit(var_indent);
    emit("}\n");
}

void parsestatforever(char * var_indent)
{
    emit(var_indent);
    emit("while (1)\n");
    emit(var_indent);
    emit("{\n");
    skipchar(var_eol);
    char * var_indentt = increaseindent(var_indent);
    parseblock(var_indentt);
    emit(var_indent);
    emit("}\n");
}

void parsestatbreak(char * var_indent)
{
    emit(var_indent);
    emit("break;\n");
    skipchar(var_eol);
}

void parsestatreturn(char * var_indent)
{
    emit(var_indent);
    emit("return ");
    char * var_char = peek();
    char * var_isspace = eq(var_char, " ");
    if (var_isspace)
    {
        skip();
        parseexprvarref();
    }
    emit(";");
    emit(var_eol);
    skipchar(var_eol);
}

void parsestatemit(char * var_indent)
{
    emit(var_indent);
    emit("emit(");
    skipchar(" ");
    char * var_char = peek();
    char * var_isquote = eq(var_char, var_quote);
    char * var_isnotquote = not(var_isquote);
    if (var_isquote)
    {
        parseconststring();
    }
    if (var_isnotquote)
    {
        parseexprvarref();
    }
    emit(");\n");
    skipchar(var_eol);
}

void parsestattrace(char * var_indent)
{
    emit(var_indent);
    emit("trace(");
    emit(var_quote);
    skipchar(" ");
    char * var_varname = lexident();
    emit(var_varname);
    emit(var_quote);
    emit(", ");
    emit(var_varname);
    emit(")\n");
    skipchar(var_eol);
}

void parsestatskipchar(char * var_indent)
{
    skipchar(" ");
    emit(var_indent);
    emit("skipchar(");
    char * var_char = peek();
    char * var_isquote = eq(var_char, var_quote);
    char * var_isnotquote = not(var_isquote);
    if (var_isquote)
    {
        parseconststring();
    }
    if (var_isnotquote)
    {
        parseexprvarref();
    }
    emit(");\n");
    skipchar(var_eol);
}

void parsestat(char * var_indent)
{
    char * var_call = lexident();
    trace("call", call)
    char * var_isset = eq(var_call, "set");
    if (var_isset)
    {
        parsestatset(var_indent);
        return ;
    }
    char * var_iscalc = eq(var_call, "calc");
    if (var_iscalc)
    {
        parsestatcalc(var_indent);
        return ;
    }
    char * var_isif = eq(var_call, "if");
    if (var_isif)
    {
        parsestatif(var_indent);
        return ;
    }
    char * var_isforever = eq(var_call, "forever");
    if (var_isforever)
    {
        parsestatforever(var_indent);
        return ;
    }
    char * var_isbreak = eq(var_call, "break");
    if (var_isbreak)
    {
        parsestatbreak(var_indent);
        return ;
    }
    char * var_isreturn = eq(var_call, "return");
    if (var_isreturn)
    {
        parsestatreturn(var_indent);
        return ;
    }
    char * var_isemit = eq(var_call, "emit");
    if (var_isemit)
    {
        parsestatemit(var_indent);
        return ;
    }
    char * var_istrace = eq(var_call, "trace");
    if (var_istrace)
    {
        parsestattrace(var_indent);
        return ;
    }
    char * var_isskipchar = eq(var_call, "skipchar");
    if (var_isskipchar)
    {
        parsestatskipchar(var_indent);
        return ;
    }
    emit(var_indent);
    emit(var_call);
    emit("(");
    char * var_first = "1";
    while (1)
    {
        char * var_char = peek();
        char * var_isspace = eq(var_char, " ");
        char * var_isnotspace = not(var_isspace);
        if (var_isnotspace)
        {
            break;
        }
        skip();
        char * var_char = peek();
        char * var_isquote = eq(var_char, var_quote);
        char * var_isnotquote = not(var_isquote);
        if (var_isquote)
        {
            parseconststring();
        }
        if (var_isnotquote)
        {
            parseexprvarref();
        }
        char * var_isfirst = eq(var_first, "1");
        char * var_isnotfirst = not(var_isfirst);
        if (var_isnotfirst)
        {
            emit(", ");
        }
        char * var_first = "0";
    }
    skipchar(var_eol);
    emit(");\n");
}

void parseblock(char * var_indent)
{
    while (1)
    {
        while (1)
        {
            char * var_char = peek();
            char * var_iseol = eq(var_char, var_eol);
            char * var_isnoteol = not(var_iseol);
            if (var_isnoteol)
            {
                break;
            }
            skip();
        }
        char * var_copy = "    ";
        while (1)
        {
            char * var_isdone = eq(var_copy, var_indent);
            if (var_isdone)
            {
                break;
            }
            skipchar("\t");
            char * var_copy = increaseindent(var_copy);
        }
        char * var_char = peek();
        char * var_iseoblock = eq(var_char, "/");
        if (var_iseoblock)
        {
            skip();
            skipchar(var_eol);
            break;
        }
        skipchar("\t");
        parsestat(var_indent);
    }
}

void parsefunc()
{
    char * var_funcname = lexident();
    trace("funcname", funcname)
    emit("void ");
    emit(var_funcname);
    emit("(");
    char * var_first = "1";
    while (1)
    {
        char * var_char = peek();
        char * var_isspace = eq(var_char, " ");
        char * var_isnotspace = not(var_isspace);
        if (var_isnotspace)
        {
            break;
        }
        skip();
        char * var_var = lexident();
        char * var_isfirst = eq(var_first, "1");
        char * var_isnotfirst = not(var_isfirst);
        if (var_isnotfirst)
        {
            emit(", ");
        }
        emit("char * var_");
        emit(var_var);
        char * var_first = "0";
    }
    skipchar(":");
    skipchar(var_eol);
    emit(")\n{\n");
    parseblock("    ");
    emit("}\n\n");
}

void emitheader()
{
    emit("char * addstringchar(char * str, char * chr)\n");
    emit("{\n");
    emit("}\n");
    emit("\n");
    emit("\n");
}

void emitfooter()
{
    emit("");
}

void main()
{
    emitheader();
    while (1)
    {
        char * var_char = peek();
        char * var_iseof = eq(var_char, var_eof);
        if (var_iseof)
        {
            break;
        }
        while (1)
        {
            char * var_char = peek();
            char * var_iseol = eq(var_char, var_eol);
            char * var_isnoteol = not(var_iseol);
            if (var_isnoteol)
            {
                break;
            }
            skip();
        }
        parsefunc();
    }
    emitfooter();
}