Clownfish-CFC
view release on metacpan or search on metacpan
charmonizer.c view on Meta::CPAN
const char*
chaz_Floats_math_library(void);
#endif /* H_CHAZ_FLOATS */
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/FuncMacro.h"
/* Charmonizer/Probe/FuncMacro.h
*/
#ifndef H_CHAZ_FUNC_MACRO
#define H_CHAZ_FUNC_MACRO
#include <stdio.h>
/* Run the FuncMacro module.
*
* If __func__ successfully resolves, this will be defined:
*
* HAS_ISO_FUNC_MACRO
*
* If __FUNCTION__ successfully resolves, this will be defined:
*
* HAS_GNUC_FUNC_MACRO
*
* If one or the other succeeds, these will be defined:
*
* HAS_FUNC_MACRO
* FUNC_MACRO
*
* The "inline" keyword will also be probed for. If it is available, the
* following macro will be defined to "inline", otherwise it will be defined
* to nothing.
*
* INLINE
*/
void chaz_FuncMacro_run(void);
#endif /* H_CHAZ_FUNC_MACRO */
/***************************************************************************/
#line 20 "src/Charmonizer/Probe/Headers.h"
/* Charmonizer/Probe/Headers.h
charmonizer.c view on Meta::CPAN
*/
void chaz_UnusedVars_run(void);
#endif /* H_CHAZ_UNUSED_VARS */
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/VariadicMacros.h"
/* Charmonizer/Probe/VariadicMacros.h
*/
#ifndef H_CHAZ_VARIADIC_MACROS
#define H_CHAZ_VARIADIC_MACROS
#include <stdio.h>
/* Run the VariadicMacros module.
*
* If your compiler supports ISO-style variadic macros, this will be defined:
*
* HAS_ISO_VARIADIC_MACROS
*
* If your compiler supports GNU-style variadic macros, this will be defined:
*
* HAS_GNUC_VARIADIC_MACROS
*
* If you have at least one of the above, this will be defined:
*
* HAS_VARIADIC_MACROS
*/
void chaz_VariadicMacros_run(void);
#endif /* H_CHAZ_VARIADIC_MACROS */
/***************************************************************************/
#line 17 "src/Charmonizer/Core/CFlags.c"
#include <string.h>
charmonizer.c view on Meta::CPAN
}
free(output);
return "m";
}
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/FuncMacro.c"
/* #include "Charmonizer/Core/Compiler.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/FuncMacro.h" */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
/* Probe for ISO func macro. */
static int
chaz_FuncMacro_probe_iso() {
static const char iso_func_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( printf("%s", __func__); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
size_t output_len;
char *output;
int success = false;
output = chaz_CC_capture_output(iso_func_code, &output_len);
if (output != NULL && strncmp(output, "main", 4) == 0) {
success = true;
}
free(output);
return success;
}
static int
chaz_FuncMacro_probe_gnu() {
/* Code for verifying GNU func macro. */
static const char gnu_func_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( printf("%s", __FUNCTION__); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
size_t output_len;
char *output;
int success = false;
charmonizer.c view on Meta::CPAN
if (output != NULL && strncmp(output, "main", 4) == 0) {
success = true;
}
free(output);
return success;
}
/* Attempt to verify inline keyword. */
static char*
chaz_FuncMacro_try_inline(const char *keyword, size_t *output_len) {
static const char inline_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( static %s int foo() { return 1; } )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( printf("%%d", foo()); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
char code[sizeof(inline_code) + 30];
sprintf(code, inline_code, keyword);
return chaz_CC_capture_output(code, output_len);
}
static void
chaz_FuncMacro_probe_inline(void) {
static const char* inline_options[] = {
"__inline",
"__inline__",
"inline"
};
const int num_inline_options = sizeof(inline_options) / sizeof(void*);
int has_inline = false;
int i;
for (i = 0; i < num_inline_options; i++) {
const char *inline_option = inline_options[i];
size_t output_len;
char *output = chaz_FuncMacro_try_inline(inline_option, &output_len);
if (output != NULL) {
has_inline = true;
chaz_ConfWriter_add_def("INLINE", inline_option);
free(output);
break;
}
}
if (!has_inline) {
chaz_ConfWriter_add_def("INLINE", NULL);
}
}
void
chaz_FuncMacro_run(void) {
int has_funcmac = false;
int has_iso_funcmac = false;
int has_gnuc_funcmac = false;
chaz_ConfWriter_start_module("FuncMacro");
/* Check for func macros. */
if (chaz_FuncMacro_probe_iso()) {
has_funcmac = true;
has_iso_funcmac = true;
}
if (chaz_FuncMacro_probe_gnu()) {
has_funcmac = true;
has_gnuc_funcmac = true;
}
/* Write out common defines. */
if (has_funcmac) {
const char *macro_text = has_iso_funcmac
? "__func__"
: "__FUNCTION__";
chaz_ConfWriter_add_def("HAS_FUNC_MACRO", NULL);
charmonizer.c view on Meta::CPAN
/* Write out specific defines. */
if (has_iso_funcmac) {
chaz_ConfWriter_add_def("HAS_ISO_FUNC_MACRO", NULL);
}
if (has_gnuc_funcmac) {
chaz_ConfWriter_add_def("HAS_GNUC_FUNC_MACRO", NULL);
}
/* Check for inline keyword. */
chaz_FuncMacro_probe_inline();
chaz_ConfWriter_end_module();
}
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/Headers.c"
charmonizer.c view on Meta::CPAN
chaz_ConfWriter_add_def("UNREACHABLE_RETURN(type)", "return (type)0");
chaz_ConfWriter_end_module();
}
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/VariadicMacros.c"
/* #include "Charmonizer/Core/Compiler.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/VariadicMacros.h" */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
/* Code for verifying ISO-style variadic macros. */
static const char chaz_VariadicMacros_iso_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( #define ISO_TEST(fmt, ...) \\ )
" printf(fmt, __VA_ARGS__) \n"
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( ISO_TEST("%d %d", 1, 1); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
/* Code for verifying GNU-style variadic macros. */
static const char chaz_VariadicMacros_gnuc_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( #define GNU_TEST(fmt, args...) printf(fmt, ##args) )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( GNU_TEST("%d %d", 1, 1); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
void
chaz_VariadicMacros_run(void) {
char *output;
size_t output_len;
int has_varmacros = false;
chaz_ConfWriter_start_module("VariadicMacros");
/* Test for ISO-style variadic macros. */
output = chaz_CC_capture_output(chaz_VariadicMacros_iso_code, &output_len);
if (output != NULL) {
has_varmacros = true;
chaz_ConfWriter_add_def("HAS_VARIADIC_MACROS", NULL);
chaz_ConfWriter_add_def("HAS_ISO_VARIADIC_MACROS", NULL);
free(output);
}
/* Test for GNU-style variadic macros. */
output = chaz_CC_capture_output(chaz_VariadicMacros_gnuc_code, &output_len);
if (output != NULL) {
if (has_varmacros == false) {
has_varmacros = true;
chaz_ConfWriter_add_def("HAS_VARIADIC_MACROS", NULL);
}
chaz_ConfWriter_add_def("HAS_GNUC_VARIADIC_MACROS", NULL);
free(output);
}
chaz_ConfWriter_end_module();
charmonizer.c view on Meta::CPAN
/* Define stdint types in charmony.h. */
chaz_ConfWriter_append_conf("#define CHY_EMPLOY_INTEGERTYPES\n\n");
chaz_ConfWriter_append_conf("#define CHY_EMPLOY_INTEGERLITERALS\n\n");
chaz_ConfWriter_append_conf("#define CHY_EMPLOY_INTEGERFORMATSTRINGS\n\n");
/* Run probe modules. */
chaz_BuildEnv_run();
chaz_DirManip_run();
chaz_Headers_run();
chaz_FuncMacro_run();
chaz_Booleans_run();
chaz_Integers_run();
chaz_Strings_run();
chaz_Memory_run();
chaz_SymbolVisibility_run();
chaz_UnusedVars_run();
chaz_VariadicMacros_run();
if (chaz_CLI_defined(cli, "enable-makefile")) {
S_write_makefile(cli);
}
/* Needed by cmark. */
if (chaz_HeadCheck_defines_symbol("va_copy", "#include <stdarg.h>")) {
chaz_ConfWriter_append_conf("#define CHY_HAS_VA_COPY\n\n");
}
lemon/lemon.c view on Meta::CPAN
struct symbol *fallback; /* The fallback token */
struct symbol *tkclass; /* Token class symbol */
struct symbol *lhs; /* Left-hand side of current rule */
const char *lhsalias; /* Alias for the LHS */
int nrhs; /* Number of right-hand side symbols seen */
struct symbol *rhs[MAXRHS]; /* RHS symbols */
const char *alias[MAXRHS]; /* Aliases for each RHS symbol (or NULL) */
struct rule *prevrule; /* Previous rule parsed */
const char *declkeyword; /* Keyword of a declaration */
char **declargslot; /* Where the declaration argument should be put */
int insertLineMacro; /* Add #line before declaration insert */
int *decllinenoslot; /* Where to write declaration line number */
enum e_assoc declassoc; /* Assign this association to decl arguments */
int preccounter; /* Assign this precedence to decl arguments */
struct rule *firstrule; /* Pointer to first rule in the grammar */
struct rule *lastrule; /* Pointer to the most recently parsed rule */
};
/* Parse a single token */
static void parseonetoken(struct pstate *psp)
{
lemon/lemon.c view on Meta::CPAN
"Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
psp->errorcnt++;
psp->state = RESYNC_AFTER_RULE_ERROR;
}
break;
case WAITING_FOR_DECL_KEYWORD:
if( ISALPHA(x[0]) ){
psp->declkeyword = x;
psp->declargslot = 0;
psp->decllinenoslot = 0;
psp->insertLineMacro = 1;
psp->state = WAITING_FOR_DECL_ARG;
if( strcmp(x,"name")==0 ){
psp->declargslot = &(psp->gp->name);
psp->insertLineMacro = 0;
}else if( strcmp(x,"include")==0 ){
psp->declargslot = &(psp->gp->include);
}else if( strcmp(x,"code")==0 ){
psp->declargslot = &(psp->gp->extracode);
}else if( strcmp(x,"token_destructor")==0 ){
psp->declargslot = &psp->gp->tokendest;
}else if( strcmp(x,"default_destructor")==0 ){
psp->declargslot = &psp->gp->vardest;
}else if( strcmp(x,"token_prefix")==0 ){
psp->declargslot = &psp->gp->tokenprefix;
psp->insertLineMacro = 0;
}else if( strcmp(x,"syntax_error")==0 ){
psp->declargslot = &(psp->gp->error);
}else if( strcmp(x,"parse_accept")==0 ){
psp->declargslot = &(psp->gp->accept);
}else if( strcmp(x,"parse_failure")==0 ){
psp->declargslot = &(psp->gp->failure);
}else if( strcmp(x,"stack_overflow")==0 ){
psp->declargslot = &(psp->gp->overflow);
}else if( strcmp(x,"extra_argument")==0 ){
psp->declargslot = &(psp->gp->arg);
psp->insertLineMacro = 0;
}else if( strcmp(x,"token_type")==0 ){
psp->declargslot = &(psp->gp->tokentype);
psp->insertLineMacro = 0;
}else if( strcmp(x,"default_type")==0 ){
psp->declargslot = &(psp->gp->vartype);
psp->insertLineMacro = 0;
}else if( strcmp(x,"stack_size")==0 ){
psp->declargslot = &(psp->gp->stacksize);
psp->insertLineMacro = 0;
}else if( strcmp(x,"start_symbol")==0 ){
psp->declargslot = &(psp->gp->start);
psp->insertLineMacro = 0;
}else if( strcmp(x,"left")==0 ){
psp->preccounter++;
psp->declassoc = LEFT;
psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
}else if( strcmp(x,"right")==0 ){
psp->preccounter++;
psp->declassoc = RIGHT;
psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
}else if( strcmp(x,"nonassoc")==0 ){
psp->preccounter++;
lemon/lemon.c view on Meta::CPAN
case WAITING_FOR_DESTRUCTOR_SYMBOL:
if( !ISALPHA(x[0]) ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Symbol name missing after %%destructor keyword");
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}else{
struct symbol *sp = Symbol_new(x);
psp->declargslot = &sp->destructor;
psp->decllinenoslot = &sp->destLineno;
psp->insertLineMacro = 1;
psp->state = WAITING_FOR_DECL_ARG;
}
break;
case WAITING_FOR_DATATYPE_SYMBOL:
if( !ISALPHA(x[0]) ){
ErrorMsg(psp->filename,psp->tokenlineno,
"Symbol name missing after %%type keyword");
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}else{
lemon/lemon.c view on Meta::CPAN
if((sp) && (sp->datatype)){
ErrorMsg(psp->filename,psp->tokenlineno,
"Symbol %%type \"%s\" already defined", x);
psp->errorcnt++;
psp->state = RESYNC_AFTER_DECL_ERROR;
}else{
if (!sp){
sp = Symbol_new(x);
}
psp->declargslot = &sp->datatype;
psp->insertLineMacro = 0;
psp->state = WAITING_FOR_DECL_ARG;
}
}
break;
case WAITING_FOR_PRECEDENCE_SYMBOL:
if( x[0]=='.' ){
psp->state = WAITING_FOR_DECL_OR_RULE;
}else if( ISUPPER(x[0]) ){
struct symbol *sp;
sp = Symbol_new(x);
lemon/lemon.c view on Meta::CPAN
ErrorMsg(psp->filename,psp->tokenlineno,
"Can't assign a precedence to \"%s\".",x);
psp->errorcnt++;
}
break;
case WAITING_FOR_DECL_ARG:
if( x[0]=='{' || x[0]=='\"' || ISALNUM(x[0]) ){
const char *zOld, *zNew;
char *zBuf, *z;
int nOld, n, nLine = 0, nNew, nBack;
int addLineMacro;
char zLine[50];
zNew = x;
if( zNew[0]=='"' || zNew[0]=='{' ) zNew++;
nNew = lemonStrlen(zNew);
if( *psp->declargslot ){
zOld = *psp->declargslot;
}else{
zOld = "";
}
nOld = lemonStrlen(zOld);
n = nOld + nNew + 20;
addLineMacro = !psp->gp->nolinenosflag && psp->insertLineMacro &&
(psp->decllinenoslot==0 || psp->decllinenoslot[0]!=0);
if( addLineMacro ){
for(z=psp->filename, nBack=0; *z; z++){
if( *z=='\\' ) nBack++;
}
lemon_sprintf(zLine, "#line %d ", psp->tokenlineno);
nLine = lemonStrlen(zLine);
n += nLine + lemonStrlen(psp->filename) + nBack;
}
*psp->declargslot = (char *) realloc(*psp->declargslot, n);
zBuf = *psp->declargslot + nOld;
if( addLineMacro ){
if( nOld && zBuf[-1]!='\n' ){
*(zBuf++) = '\n';
}
memcpy(zBuf, zLine, nLine);
zBuf += nLine;
*(zBuf++) = '"';
for(z=psp->filename; *z; z++){
if( *z=='\\' ){
*(zBuf++) = '\\';
}
modules/CommonMark/src/inlines.c view on Meta::CPAN
static const char *EMDASH = "\xE2\x80\x94";
static const char *ENDASH = "\xE2\x80\x93";
static const char *ELLIPSES = "\xE2\x80\xA6";
static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C";
static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D";
static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98";
static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99";
// Macros for creating various kinds of simple.
#define make_str(s) make_literal(CMARK_NODE_TEXT, s)
#define make_code(s) make_literal(CMARK_NODE_CODE, s)
#define make_raw_html(s) make_literal(CMARK_NODE_INLINE_HTML, s)
#define make_linebreak() make_simple(CMARK_NODE_LINEBREAK)
#define make_softbreak() make_simple(CMARK_NODE_SOFTBREAK)
#define make_emph() make_simple(CMARK_NODE_EMPH)
#define make_strong() make_simple(CMARK_NODE_STRONG)
typedef struct delimiter {
struct delimiter *previous;
src/CFCLexHeader.c view on Meta::CPAN
void yyset_out (FILE * out_str );
yy_size_t yyget_leng (void );
char *yyget_text (void );
int yyget_lineno (void );
void yyset_lineno (int line_number );
/* Macros after this point can all be overridden by user definitions in
* section 1.
*/
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap (void );
#else
extern int yywrap (void );
#endif
#endif
src/CFCLexHeader.h view on Meta::CPAN
void yyset_out (FILE * out_str );
yy_size_t yyget_leng (void );
char *yyget_text (void );
int yyget_lineno (void );
void yyset_lineno (int line_number );
/* Macros after this point can all be overridden by user definitions in
* section 1.
*/
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap (void );
#else
extern int yywrap (void );
#endif
#endif
( run in 0.648 second using v1.01-cache-2.11-cpan-49f99fa48dc )