コード例 #1
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load boolean */
int cx_xmlnodeBool(cx_xmlnode cnode, unsigned int* out) {
    char* str;
    int result;
    xmlNodePtr node = (xmlNodePtr)cnode;

    cx_assert(out != 0, "Invalid out parameter.");

    result = -1;

    str = (char*)xmlNodeGetContent(node);
    if (str) {
        result = 0;
        if (!strcmp("true", str) || !strcmp("TRUE", str)) {
            *out = 1;
        } else if (!strcmp("false", str) || !strcmp("FALSE", str)){
            *out = 0;
        } else {
            result = -1;
            cx_error("invalid boolean value '%s' in node '%s'.", str, node->name);
        }
        free(str);
    } else {
        cx_error("node '%s' has no content (expected integer).", node->name);
    }

    return result;
}
コード例 #2
0
ファイル: parse_statement.cpp プロジェクト: DTSCode/Cx
void cx_parser::parse_case_label(cx_symtab_node* p_function_id, const cx_type *p_expr_type) {
    get_token_append();

    bool sign_flag(false);

    if (token_in(token, tokenlist_unary_ops)) {
        sign_flag = true;
        get_token_append();
    }

    switch (token) {
        case tc_identifier:
            if (!search_all(p_token->string__())) {
                cx_error(err_undefined_identifier);
            }

            get_token_append();
            break;
        case tc_number:
            if (p_token->type() != ty_integer) cx_error(err_invalid_constant);
            get_token_append();
            break;
        case tc_string:
            if (sign_flag || (strlen(p_token->string__()) != 3)) {
                cx_error(err_invalid_constant);
            }
            break;
        default:
            break;
    }

    conditional_get_token_append(tc_colon, err_missing_colon);

    parse_statement_list(p_function_id, tc_BREAK);
}
コード例 #3
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load boolean from attribute */
int cx_xmlnodeAttrBool(cx_xmlnode cnode, const char* attribute, unsigned int* out) {
    char* str;
    int result;
    xmlNodePtr node = (xmlNodePtr)cnode;

    cx_assert(out != 0, "Invalid out parameter.");

    result = -1;

    str = (char*)xmlGetProp(node, (xmlChar*)attribute);
    if (str) {
        result = 0;
        if (!strcmp("true", str) || !strcmp("TRUE", str) || !strcmp("True", str)) {
            *out = 1;
        } else if (!strcmp("false", str) || !strcmp("FALSE", str) || !strcmp("False", str)){
            *out = 0;
        } else {
            result = -1;
            cx_error("invalid boolean value '%s' in attribute '%s' of node '%s'.", str, attribute, node->name);
        }
        free(str);
    } else {
        cx_error("boolean attribute '%s' not found in node '%s'.", attribute, node->name);
    }

    return result;
}
コード例 #4
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Open xml file */
cx_xmlreader cx_xmlreaderNew(const char* file, const char* rootElement) {
    xmlDocPtr doc;
    xmlNodePtr root;
    cx_xmlreader reader;

    reader = 0;

    if (!xml_initialized) {
        xmlInitParser();
        xml_initialized = TRUE;
    }

    doc = xmlParseFile(file);
    if (doc) {
        root = xmlDocGetRootElement(doc);
        assert(root);

        if (xmlStrcmp(root->name, (const xmlChar*)rootElement)) {
            cx_error("incorrect root element '%s' (expected '%s').", root->name, rootElement);
            xmlFreeDoc(doc);
            doc = 0;
        } else {
            reader = malloc(sizeof(cx_xmlreader_s));
            reader->doc = doc;
            reader->root = root;
        }
    }

    return reader;
}
コード例 #5
0
ファイル: cortex.c プロジェクト: jeffplourde/cortex
int main(int argc, char* argv[]) {
    int i;

    /* Start database */
    cx_start();

    /* Parse arguments */
    for(i=1; i<argc; i++) {
        if (*argv[i] == '-') {
            if (*(argv[i]+1) == 'd') {
                CX_DEBUG_ENABLED = TRUE;
            }
        } else {
            if (cx_load(argv[i])) {
                cx_error("cortex: failed to load file '%s'", argv[i]);
                goto error;
            }
        }
    }

    /* Stop database */
    cx_stop();

    return 0;
error:
    return -1;
}
コード例 #6
0
ファイル: cx_type.c プロジェクト: jeffplourde/cortex
/* ::cortex::lang::type::copy(any value) */
cx_int16 cx_type_copy(cx_any _this, cx_any value) {
/* $begin(::cortex::lang::type::copy) */
    cx_copy_ser_t data;
    struct cx_serializer_s s;
    cx_value v1;
    cx_int16 result;

    if (_this.type->reference || value.type->reference) {
        cx_valueObjectInit(&data.value, _this.value);
        cx_valueObjectInit(&v1, value.value);       
    } else {
        cx_valueValueInit(&data.value, NULL, cx_type(_this.type), _this.value);
        cx_valueValueInit(&v1, NULL, cx_type(value.type), value.value);
    }
    
    s = cx_copy_ser(CX_PRIVATE, CX_NOT, CX_SERIALIZER_TRACE_ON_FAIL);
    
    result = cx_serializeValue(&s, &v1, &data);

    if (result) {
        cx_id id, id2;
        cx_error("type::copy: failed to copy value of type '%s' to value of type '%s'",
                 cx_fullname(_this.type, id), cx_fullname(value.type, id2));
    }
    
    return result;
/* $end */
}
コード例 #7
0
ファイル: cx_type.c プロジェクト: jeffplourde/cortex
cx_int16 cx_type_bindMetaprocedure(cx_type _this, cx_metaprocedure procedure) {
    cx_function* f;
    cx_int32 d = 0;

    /* Check if function is overloaded */
    if ((f = cx_vtableLookup(&_this->metaprocedures, cx_nameof(procedure), NULL, &d))) {
        if (d) {
            cx_function(*f)->overloaded = TRUE; /* Flag found and passed function as overloaded. */
            cx_function(procedure)->overloaded = TRUE;
        } else {
            if (*f != cx_function(procedure)) {
                /* Overriding metaprocedures is not allowed. */
                cx_id id, id2;
                cx_error("definition of metaprocedure '%s' conflicts with existing metaprocedure '%s'", cx_fullname(*f, id), cx_fullname(procedure, id2));
                goto error;
            }
        }
    }

    if (cx_vtableInsert(&_this->metaprocedures, cx_function(procedure))) {
        cx_keep_ext(_this, procedure, "Bind metaprocedure to type.");
    }
    return 0;
error:
    return -1;
}
コード例 #8
0
ファイル: symtable.cpp プロジェクト: DTSCode/Cx
/** enter_new    search the symbol table for the given name
 *              string.  If the name is not already in there,
 *              enter it.  Otherwise, flag the redefined
 *              identifier error.
 *
 * @param p_string : ptr to name string to enter.
 * @param dc      : definition code.
 * @return ptr to symbol table node.
 */
cx_symtab_node *cx_symtab::enter_new(const char *p_string, cx_define_code dc) {
    cx_symtab_node *p_node = search(p_string);

    if (!p_node) p_node = enter(p_string, dc);
    else cx_error(err_redefined_identifier);

    return p_node;
}
コード例 #9
0
ファイル: io_file.c プロジェクト: jeffplourde/cortex
/* ::cortex::io::file::construct() */
cx_int16 io_file_construct(io_file _this) {
/* $begin(::cortex::io::file::construct) */
    if (_this->name) {\
        /* Special directive, for opening stdout, stdin and stderr */
        if (*_this->name == '#') {
            if (!strcmp(_this->name, "#out")) {
                _this->handle = (cx_word)stdout;
            } else if (!strcmp(_this->name, "#in")) {
                _this->handle = (cx_word)stdin;
            } else if (!strcmp(_this->name, "#err")) {
                _this->handle = (cx_word)stderr;
            } else {
                cx_error("unknown file-directive '%s'", _this->name);
                goto error;
            }
        } else {
            if (!_this->binary) {
                switch(_this->mode) {
                case Io_Read:   _this->handle = (cx_word)fopen(_this->name, "r"); break;
                case Io_Write:  _this->handle = (cx_word)fopen(_this->name, "w"); break;
                case Io_Append: _this->handle = (cx_word)fopen(_this->name, "a"); break;
                default: cx_error("invalid filemode specified."); break;
                }
            } else {
                switch(_this->mode) {
                case Io_Read:   _this->handle = (cx_word)fopen(_this->name, "rb"); break;
                case Io_Write:  _this->handle = (cx_word)fopen(_this->name, "wb"); break;
                case Io_Append: _this->handle = (cx_word)fopen(_this->name, "ab"); break;
                default: cx_error("invalid filemode specified."); break;
                }
            }
            if (!_this->handle) {
                cx_error("failed to open file '%s'", _this->name);
            }
        }
    } else {
        cx_error("invalid filename.");
        goto error;
    }

    return 0;
error:
    return -1;
/* $end */
}
コード例 #10
0
ファイル: cx.c プロジェクト: gitter-badger/cortex
/* Define type */
static void cx_defineType(cx_object o, cx_uint32 size) {
    cx_defineObject(o);

    /* Size validation */
    if (cx_type(o)->size != size) {
        cx_id id;
        cx_error("bootstrap: size validation failed for type '%s' - metatype = %d, c-type = %d.", cx_fullname(o, id), cx_type(o)->size, size);
    }
}
コード例 #11
0
ファイル: symtable.cpp プロジェクト: DTSCode/Cx
/** enter_scope	enter a new nested scope.  Increment the nesting
 *		level.  push new scope's symbol table onto the
 *		stack.
 *
 */
void cx_symtab_stack::enter_scope(void) {

    if (++current_nesting_level > max_nesting_level) {
        cx_error(err_nesting_too_deep);
        abort_translation(abort_nesting_too_deep);
    }

    set_current_symtab(new cx_symtab);
}
コード例 #12
0
ファイル: symtable.cpp プロジェクト: DTSCode/Cx
/** find        search the symbol table stack for the given
 *              name string.  If the name is not already in
 *              there, flag the undefined identifier error,
 *		and then enter the name into the local symbol
 *		table.
 *
 * @param p_string : ptr to name string to find.
 * @return ptr to symbol table node.
 */
cx_symtab_node *cx_symtab_stack::find(const char *p_string) const {
    cx_symtab_node *p_node = search_all(p_string);

    if (!p_node) {
        cx_error(err_undefined_identifier);
        p_node = p_symtabs[current_nesting_level]->enter(p_string);
    }

    return p_node;
}
コード例 #13
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load string from attribute */
char* cx_xmlnodeAttrStr(cx_xmlnode cnode, const char* attribute) {
    char* str;
    xmlNodePtr node = (xmlNodePtr)cnode;

    str = (char*)xmlGetProp(node, (xmlChar*)attribute);
    if (!str) {
        cx_error("string attribute '%s' not found in node '%s'.", attribute, node->name);
    }

    return str;
}
コード例 #14
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load string */
char* cx_xmlnodeStr(cx_xmlnode cnode) {
    char* str;
    xmlNodePtr node = (xmlNodePtr)cnode;

    str = (char*)xmlNodeGetContent(node);
    if (!str) {
        cx_error("node %s has no content (expected string).", node->name);
    }

    return str;
}
コード例 #15
0
ファイル: symtable.cpp プロジェクト: rackbone/Cx
/** enter_scope	enter a new nested scope.  Increment the nesting
 *		level.  push new scope's symbol table onto the
 *		stack.
 *
 */
void cx_symtab_stack::enter_scope(void) {

    // dont overwrite mains scope
    //if (current_nesting_level <= 1)++current_nesting_level;

    if (++current_nesting_level > max_nesting_level) {
        cx_error(err_nesting_too_deep);
        abort_translation(abort_nesting_too_deep);
    }

    set_current_symtab(new cx_symtab);
}
コード例 #16
0
ファイル: cx_list.c プロジェクト: jeffplourde/cortex
/* ::cortex::lang::list::construct() */
cx_int16 cx_list_construct(cx_list _this) {
/* $begin(::cortex::lang::list::construct) */
    cx_type(_this)->hasResources = TRUE;
    cx_type(_this)->size = sizeof(cx_ll);
    cx_type(_this)->alignment = CX_ALIGNMENT(cx_ll);
    if (!cx_collection(_this)->elementType) {
        cx_error("no elementtype provided for list");
        goto error;
    }
    return cx_type_construct(cx_type(_this));
error:
    return -1;
/* $end */
}
コード例 #17
0
ファイル: parse_statement.cpp プロジェクト: DTSCode/Cx
/** parse_SWITCH         parse switch statements.
 *
 *      switch(<expression>){
 *              case <const-expression>:
 *              default:
 *      }
 *
 * NOTE:
 *      Broken/not implemented yet.
 *
 * @param p_function_id : ptr to this statements function Id.
 */
void cx_parser::parse_SWITCH(cx_symtab_node* p_function_id) {

    get_token_append();
    conditional_get_token_append(tc_left_paren, err_missing_left_paren);

    cx_type *p_expr_type = parse_expression()->base_type();

    conditional_get_token_append(tc_right_paren, err_missing_right_paren);

    if ((p_expr_type != p_integer_type)
            && (p_expr_type != p_char_type)
            && (p_expr_type->form != fc_enum)) {
        cx_error(err_incompatible_types);
    }

    parse_statement(p_function_id);

}
コード例 #18
0
ファイル: cx_type.c プロジェクト: jeffplourde/cortex
/* ::cortex::lang::type::parentof() */
cx_object cx_type_parentof(cx_any _this) {
/* $begin(::cortex::lang::type::parentof) */
    cx_string result = NULL;

   if (cx_checkAttr(_this.value, CX_ATTR_SCOPED)) {
       result = cx_parentof(_this.value);
   } else {
       cx_id id;
       cx_error("cannot get parent from non-scoped object of type '%s'", cx_fullname(cx_typeof(_this.value), id));
   }
    
   if (result) {
       cx_keep(result);
   }

   return result;
/* $end */
}
コード例 #19
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load unsigned int */
int cx_xmlnodeUint(cx_xmlnode cnode, unsigned int* out) {
    char* str;
    int result;
    xmlNodePtr node = (xmlNodePtr)cnode;

    cx_assert(out != 0, "Invalid out parameter.");

    result = -1;

    str = (char*)xmlNodeGetContent(node);
    if (str) {
        *out = atoi(str);
        result = 0;
    } else {
        cx_error("node '%s' has no content (expected integer).", node->name);
    }

    return result;
}
コード例 #20
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load int */
float cx_xmlnodeFloat(cx_xmlnode cnode, float* out) {
    char* str;
    float result;
    xmlNodePtr node = (xmlNodePtr)cnode;

    cx_assert(out != 0, "Invalid out parameter.");

    result = -1;

    str = (char*)xmlNodeGetContent(node);
    if (str) {
        *out = (float)atof(str);
        result = 0;
    } else {
        cx_error("node '%s' has no content (expected float).", node->name);
    }

    return result;
}
コード例 #21
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load unsigned int from attribute */
int cx_xmlnodeAttrUint(cx_xmlnode cnode, const char* attribute, unsigned int* out) {
    char* str;
    int result;
    xmlNodePtr node = (xmlNodePtr)cnode;

    cx_assert(out != 0, "Invalid out parameter.");

    result = -1;

    str = (char*)xmlGetProp(node, (xmlChar*)attribute);
    if (str) {
        *out = atoi(str);
        free(str);
        result = 0;
    } else {
        cx_error("integer attribute '%s' not found in node '%s'.", attribute, node->name);
    }

    return result;
}
コード例 #22
0
ファイル: cx_xmlreader.c プロジェクト: jeffplourde/cortex
/* Load float from attribute */
float cx_xmlnodeAttrFloat(cx_xmlnode cnode, const char* attribute, float* out) {
    char* str;
    float result;
    xmlNodePtr node = (xmlNodePtr)cnode;

    cx_assert(out != 0, "Invalid out parameter.");

    result = -1;

    str = (char*)xmlGetProp(node, (xmlChar*)attribute);
    if (str) {
        *out = (float)atof(str);
        free(str);
        result = 0;
    } else {
        cx_error("float attribute '%s' not found in node '%s'.", attribute, node->name);
    }

    return result;
}
コード例 #23
0
ファイル: cx_constant.c プロジェクト: jeffplourde/cortex
/* ::cortex::lang::constant::init() */
cx_int16 cx_constant_init(cx_constant *_this) {
/* $begin(::cortex::lang::constant::init) */
    cx_object parent;

    parent = cx_parentof(_this);

    /* Parent must be an enum */
    if (cx_typeof(parent) == cx_type(cx_enum_o)) {
        cx__enum_bindConstant(parent, _this);
    } else if (cx_typeof(parent) == cx_type(cx_bitmask_o)) {
        cx__bitmask_bindConstant(parent, _this);
    } else {
        cx_id id;
        cx_error("::constant::init: parent of constant '%s' is not an enum.", cx_fullname(_this, id));
        goto error;
    }

    return 0;
error:
    return -1;/* $end */
}
コード例 #24
0
ファイル: cx_function.c プロジェクト: jeffplourde/cortex
static int cx_functionLookupWalk(cx_object o, void* userData) {
    cx_functionLookup_t* data;
    cx_int32 d;

    data = userData;

    if (o != data->f) {
        if ((cx_class_instanceof(cx_procedure_o, cx_typeof(o)))) {
            if (cx_overload(o, cx_nameof(data->f), &d, FALSE)) {
                data->error = TRUE;
                goto finish;
            }

            /* Check if function matches */
            if (!d) {
                cx_id id, id2;
                cx_error("function '%s' conflicts with existing declaration '%s'", cx_fullname(data->f, id), cx_fullname(o, id2));
                data->error = TRUE;
                goto finish;
            } else {
                cx_id id;

                /* Get name of function */
                cx_signatureName(cx_nameof(o), id);

                /* Set overloading flags if a function with same name is found. */
                if (!strcmp(data->name, id)) {
                    cx_function(o)->overloaded = TRUE;
                    data->f->overloaded = TRUE;
                }
            }
        }
    }

    return 1;
finish:
    return 0;
}
コード例 #25
0
ファイル: cx_struct.c プロジェクト: jeffplourde/cortex
/* ::cortex::lang::struct::construct() */
cx_int16 cx_struct_construct(cx_struct _this) {
/* $begin(::cortex::lang::struct::construct) */
    cx_struct base;
    cx_uint16 alignment;
    cx_uint32 size;

    size = 0;
    alignment = 0;

    /* Insert members */
    if (cx__interface_insertMembers(cx_interface(_this))) {
        goto error;
    }

    /* Calculate alignment of self */
    if (cx_interface(_this)->members.length) {
        alignment = cx__interface_calculateAlignment(cx_interface(_this));
        if (!alignment) {
            cx_id id;
            cx_error("error in definition of '%s'", cx_fullname(_this, id));
            goto error;            
        }
    }

    /* Check if struct inherits from another struct */
    base = (cx_struct)cx_interface(_this)->base;

    /* Get maximum alignment from self and base-class and copy template parameters */
    if (base) {
        if (!cx_instanceof(cx_type(cx_struct_o), base)) {
            cx_id id, id2;
            cx_error("struct '%s' inherits from non-struct type '%s'", cx_fullname(_this, id), cx_fullname(base, id2));
            goto error;
        }

        if (cx_type(base)->alignment) {
            if (alignment < cx_type(base)->alignment) {
                alignment = cx_type(base)->alignment;
            }
        }
    }

    /* Set alignment of self */
    cx_type(_this)->alignment = alignment;

    /* Get size of base-class */
    if (base) {
        size = cx_type(base)->size;

        if (cx_type(base)->hasResources) {
            cx_type(_this)->hasResources = TRUE;
        }
    }

    /* Calculate size of self */
    if (cx_interface(_this)->members.length) {
        size = cx__interface_calculateSize(cx_interface(_this), size);
        if (!size) {
            cx_id id;
            cx_error("error in definition of '%s'", cx_fullname(_this, id));
            goto error;
        }
    }

    /* Set size of self */
    cx_type(_this)->size = size;

    return cx_interface_construct(cx_interface(_this));
error:
    return -1;
/* $end */
}
コード例 #26
0
ファイル: cx.c プロジェクト: gitter-badger/cortex
/* Define object */
static void cx_defineObject(cx_object o) {
    if (cx_define(o)) {
        cx_error("construction of builtin-object '%s' failed.", cx_nameof(o));
    }
}
コード例 #27
0
ファイル: cx_function.c プロジェクト: jeffplourde/cortex
/* ::cortex::lang::function::stringToParameterSeq(string name,object scope) */
cx_parameterSeq cx_function_stringToParameterSeq(cx_string name, cx_object scope) {
/* $begin(::cortex::lang::function::stringToParameterSeq) */
    cx_parameterSeq result = {0, NULL};

    cx_char* ptr;

    ptr = strchr(name, '(');
    if (!ptr) {
        cx_error("missing argumentlist in name for signature '%s'", name);
        goto error;
    }
    ptr++;

    /* Check if function has arguments */
    if (*ptr != ')') {
        cx_int32 count = 0, i = 0;
        cx_id id;
        int flags = 0;

        /* Count number of parameters for function */
        count = cx_signatureParamCount(name);
        if (count == -1) {
            goto error;
        }

        /* Allocate size for parameters */
        result.length = count;
        result.buffer = cx_malloc(sizeof(cx_parameter) * count);
        memset(result.buffer, 0, sizeof(cx_parameter) * count);

        /* Parse arguments */
        for(i=0; i<count; i++) {
            if (cx_signatureParamType(name, i, id, &flags)) {
                cx_error("error occurred while parsing type of parameter '%d' for signature '%s'", i, name);
                goto error;
            }

            /* Set reference */
            result.buffer[i].passByReference = (flags & CX_PARAMETER_REFERENCE) != 0;

            /* Assign type */
            result.buffer[i].type = cx_resolve_ext(NULL, scope, id, FALSE, "Resolve parameter-type for function");
            if (!result.buffer[i].type) {
                cx_error("type '%s' of parameter %d in signature %s not found", id, i, name);
                goto error;
            }

            /* Validate whether reference is not redundantly applied */
            if (result.buffer[i].passByReference && result.buffer[i].type->reference) {
                cx_id id;
                cx_error("redundant '&' qualifier for parameter %d, type '%s' is already a reference",
                    i, cx_fullname(result.buffer[i].type, id));
                goto error;
            }

            /* Parse name */
            if (cx_signatureParamName(name, i, id)) {
                cx_error("error occurred while parsing name of argument '%s' for signature '%s'", name);
                goto error;
            }

            result.buffer[i].name = cx_strdup(id);
        }
    }

    return result;
error:
    result.length = -1;
    cx_dealloc(result.buffer);
    result.buffer = NULL;
    return result;
/* $end */
}