static kBasicBlock* new_BasicBlockLABEL(KonohaContext *kctx)
{
kBasicBlock *bb = new_(BasicBlock, 0);
bb->id = kArray_size(ctxcode->codeList);
KLIB kArray_add(kctx, ctxcode->codeList, bb);
return bb;
}
static void SugarModule_Setup(KonohaContext *kctx, struct KRuntimeModel *def, int newctx)
{
if(!newctx && kctx->localContexts[ParserModelIndex] == NULL) {
KParserContext *base = (KParserContext *)KCalloc_UNTRACE(sizeof(KParserContext), 1);
base->h.reftrace = KParserContext_Reftrace;
base->h.free = KParserContext_Free;
base->errorMessageCount = 0;
base->preparedTokenList = new_(TokenArray, K_PAGESIZE/sizeof(void *), OnContextConstList);
base->errorMessageList = new_(StringArray, 8, OnContextConstList);
base->definedMethodList = new_(MethodArray, 8, OnContextConstList);
KLIB KArray_Init(kctx, &base->errorMessageBuffer, K_PAGESIZE);
kctx->localContexts[ParserModelIndex] = (KModelContext *)base;
}
}
static kToken* new_ParsedExprToken(KonohaContext *kctx, kNameSpace *ns, kExpr *expr)
{
kTokenVar *ParsedExprToken = new_(TokenVar, 0, OnGcStack);
ParsedExprToken->resolvedSyntaxInfo = SYN_(ns, KW_ExprPattern);
KFieldSet(ParsedExprToken, ParsedExprToken->parsedExpr, expr);
return (kToken *)ParsedExprToken;
}
/*#####################################################*/
bool board_init()
{
//RtcStruct.Rtc_ClkSource = _Rtc_Clk_Source_RCOSC_gc;
core_init();
//timer_init();
/*-----------------------------------------------------*/
/* Set up the Uart 0 like debug interface with RxBuff = 256, TxBuff = 256, 115200b/s*/
DebugCom = new_(new_uart);
DebugCom->BaudRate = 115200;
DebugCom->RxBuffSize = 20;
DebugCom->TxBuffSize = 10;
//DebugCom->Mode = UsartCom_Mode_Asynchronus;
DebugCom->Priority = 0;
DebugCom->UartNr = 5;
uart_open(DebugCom);
/*-----------------------------------------------------*/
/* Display board message*/
#if defined(BOARD_MESSAGE)
UARTPutc(DebugCom, 0xFF);
UARTPutc(DebugCom, 0xFF);
UARTPutc(DebugCom, '\n');
UARTPutc(DebugCom, '\r');
UARTprintf(DebugCom, "Use %s Board.\n\r", BOARD_MESSAGE);
#endif
/*-----------------------------------------------------*/
HARDBTN1 = gpio_assign(0, 1, GPIO_DIR_INPUT);
gpio_up_dn(HARDBTN1, 1);
/*-----------------------------------------------------*/
LED1 = gpio_assign(3, 12, GPIO_DIR_OUTPUT);
LED2 = gpio_assign(3, 13, GPIO_DIR_OUTPUT);
LED3 = gpio_assign(3, 14, GPIO_DIR_OUTPUT);
LED4 = gpio_assign(3, 15, GPIO_DIR_OUTPUT);
/*-----------------------------------------------------*/
return true;
}
knh_Bytes_t* new_Bytes(Ctx *ctx, size_t capacity)
{
knh_Bytes_t *ba = new_(Bytes);
if(capacity > 0) {
knh_Bytes_expands(ctx, ba, capacity);
}
return ba;
}
void *malloc_(size_t size)
{
if (size == 0)
return (NULL);
if (g_malloc_memory == NULL)
g_malloc_memory = new_(sizeof(t_chunk));
return (chunk_find(size));
}
// Copied from namespace.h.
static void kNameSpace_AppendArrayRef(KonohaContext *kctx, kNameSpace *ns, const kArray **arrayRef, kObject *o)
{
if(arrayRef[0] == NULL) {
((kArray**)arrayRef)[0] = new_(Array, 0, ns->NameSpaceConstList);
}
DBG_ASSERT(IS_Array(arrayRef[0]));
KLIB kArray_Add(kctx, arrayRef[0], o);
}
KNHAPI(knh_OutputStream_t*) new_BytesOutputStream(Ctx *ctx, knh_Bytes_t *ba)
{
knh_OutputStream_t* w = new_(OutputStream);
KNH_SETv(ctx, DP(w)->ba, ba);
knh_OutputStream_setBOL(w, 1);
knh_OutputStream_setStoringBuffer(w, 1);
return w;
}
static void SugarModule_Setup(KonohaContext *kctx, struct KonohaModule *def, int newctx)
{
if(!newctx && kctx->modlocal[MOD_sugar] == NULL) {
SugarContext *base = (SugarContext *)KCalloc_UNTRACE(sizeof(SugarContext), 1);
base->h.reftrace = SugarContext_Reftrace;
base->h.free = SugarContext_Free;
base->errorMessageCount = 0;
base->preparedTokenList = new_(TokenArray, K_PAGESIZE/sizeof(void *), OnContextConstList);
base->errorMessageList = new_(StringArray, 8, OnContextConstList);
base->definedMethodList = new_(MethodArray, 8, OnContextConstList);
base->preparedGamma = new_(Gamma, NULL, OnContextConstList);
KLIB Karray_Init(kctx, &base->errorMessageBuffer, K_PAGESIZE);
kctx->modlocal[MOD_sugar] = (KonohaModuleContext *)base;
}
}
// 画像ファイルを読み込み、
// type,width,heightを計算
// @param file_name 読み込む画像ファイル名
int open_ImageFile(ImageData *this_,const char *file_name){
FILE *fp;
this_->width = -1;
this_->height = -1;
this_->type = Type_NONE;
if((fp = fopen(file_name,"rb")) == NULL){
fprintf(stderr,
"error: %s(%d)::open_ImageFile() - cannot open File '%s'\n",
__FILE__,__LINE__,file_name);
return -1;
}
// ファイルサイズを求める
{
fpos_t fsize;
// MinGW では __pos が不要
#if __WIN32__
fsize = 0;
#else
fsize.__pos = 0;
#endif
fseek(fp,0,SEEK_END);
fgetpos(fp,&fsize);
// MinGW では __pos が不要
#if __WIN32__
this_->data_size = (unsigned int)fsize;
#else
this_->data_size = (unsigned int)fsize.__pos;
#endif
rewind(fp);
}
// 領域確保とデータ読み込み
this_->raw_data = (byte*)new_(this_->data_size);
{
int c;
unsigned int i;
for(i=0;i<this_->data_size; i++){
if(feof(fp) || (c=fgetc(fp))==EOF){
fprintf(stderr,
"error: %s(%d)::open_ImageFile() - can not read File '%s'\n",
__FILE__,__LINE__,file_name);
this_->data_size = 0;
delete_(this_->raw_data);
fclose(fp);
this_->raw_data = NULL;
return -1;
}
this_->raw_data[i] = (byte)c;
}
}
fclose(fp);
// 画像のフォーマット特定、サイズの計算
calcImageSize(this_);
return 0;
}
static void KRuntimeContext_Init(KonohaContext *kctx, KonohaContextVar *ctx, size_t stacksize)
{
size_t i;
KRuntimeContextVar *base = (KRuntimeContextVar *)KCalloc_UNTRACE(sizeof(KRuntimeContextVar), 1);
base->stacksize = stacksize;
base->stack = (KonohaStack *)KCalloc_UNTRACE(sizeof(KonohaStack), stacksize);
assert(stacksize>64);
base->stack_uplimit = base->stack + (stacksize - 64);
for(i = 0; i < stacksize; i++) {
KUnsafeFieldInit(base->stack[i].asObject, K_NULL);
}
KUnsafeFieldInit(base->ContextConstList, new_(Array, 8, OnField));
KUnsafeFieldInit(base->ThrownException, (kException *)K_NULL);
base->gcStack = new_(Array, K_PAGESIZE/sizeof(void *), base->ContextConstList);
KLIB KArray_Init(kctx, &base->cwb, K_PAGESIZE * 4);
ctx->esp = base->stack;
ctx->stack = base;
}
static KMETHOD TypeCheck_RegExp(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, expr, gma, reqty);
kToken *tk = expr->termToken;
kRegExp *r = new_(RegExp, NULL, OnGcStack);
DBG_ASSERT(kArray_size(tk->subTokenList) == 2);
RegExp_set(kctx, r, tk->subTokenList->stringItems[0], tk->subTokenList->stringItems[1]);
KReturn(SUGAR kExpr_setConstValue(kctx, expr, TY_RegExp, UPCAST(r)));
}
knh_Bytes_t* new_Bytes(CTX ctx, const char *name, size_t capacity)
{
knh_Bytes_t *ba = new_(Bytes);
ba->DBG_name = name;
if(capacity > 0) {
knh_Bytes_expands(ctx, ba, capacity);
}
return ba;
}
ptr CON194_create_(ptr self__, int ln__)
{
ptr res__ = 0;
res__ = (ptr)new_(194,0);
IATT_(res__,4) = (int)ln__;
ret0__:
return (res__);
}
ptr TYP114_create_(ptr self__)
{
ptr res__ = 0;
res__ = (ptr)new_(114,1);
IATT_(res__,4) = (int)GLO68_curr_lineno_;
ret0__:
return (res__);
}
void ksampleshare_setup(CTX, struct kmodshare_t *def)
{
if(_ctx->mod[MOD_SAMPLE] == NULL) {
ksamplemod_t *mod = (ksamplemod_t *) KCALLOC(sizeof(ksamplemod_t));
mod->h.reftrace = ksamplemod_reftrace;
mod->h.free = ksamplemod_free;
KINITv(mod->array, new_(Array, 8));
_ctx->mod[MOD_SAMPLE] = (kmodlocal_t*)mod;
}
}
knh_OutputStream_t* new_OutputStreamDSPI(Ctx *ctx, knh_io_t fd, const knh_StreamDSPI_t *dspi)
{
knh_OutputStream_t* w = new_(OutputStream);
// KNH_SETv(ctx, DP(w)->urn, urn);
DP(w)->fd = fd;
SP(w)->dspi = dspi;
//KNH_SETv(ctx, DP(w)->ba, new_Bytes(ctx, K_PAGESIZE));
knh_OutputStream_setBOL(w,1);
return w;
}
ptr ASS135_create_(ptr self__, ptr a__, int ln__)
{
ptr res__ = 0;
res__ = (ptr)new_(135,0);
PATT_(res__,16) = (ptr)a__;
IATT_(res__,4) = (int)ln__;
ret0__:
return (res__);
}
// reallocのラッパー
// エラー時には perror を実行し、exit
void* renew_(void *ptr,size_t size){
if(ptr == NULL) return new_(size);
void* ret = realloc(ptr,size);
if(size == 0) return NULL;
if(ret == NULL){
CERRP("realloc(ptr,%d)", (int)size);
perror("realloc in my_stdlib.c");
exit(EXIT_FAILURE);
}
return ret;
}
static KMETHOD Statement_syntax(KonohaContext *kctx, KonohaStack *sfp)
{
kbool_t r = 0;
VAR_Statement(stmt, gma);
kTokenArray *tokenList = (kTokenArray *)kStmt_GetObject(kctx, stmt, KW_TokenPattern, NULL);
if(tokenList == NULL) {
SUGAR kStmt_Message2(kctx, stmt, NULL, ErrTag, "empty syntax");
}
if(tokenList != NULL) {
if(!IS_Array(tokenList)) { // create tokenList from a Token
kTokenArray *a = new_(TokenArray, 0, OnGcStack);
KLIB kArray_Add(kctx, a, tokenList);
tokenList = a;
}
DBG_ASSERT(IS_Array(tokenList));
kNameSpace *ns = Stmt_ns(stmt);
SugarSyntaxVar *syn = kNameSpace_guessSyntaxFromTokenList(kctx, ns, tokenList);
if(syn != NULL) {
if(syn->syntaxPatternListNULL_OnList != NULL) {
SUGAR kStmt_Message2(kctx, stmt, NULL, InfoTag, "oveloading syntax: %s%s", PSYM_t(syn->keyword));
}
else {
syn->syntaxPatternListNULL_OnList = new_(TokenArray, 0, ns->NameSpaceConstList);
}
TokenSeq tokens = {ns, tokenList, 0, kArray_size(tokenList)};
// Referred to kNameSpace_ParseSyntaxPattern in ast.h.
kArray *patternList = syn->syntaxPatternListNULL_OnList;
size_t firstPatternIdx = kArray_size(patternList);
SUGAR kArray_AddSyntaxRule(kctx, patternList, &tokens);
if(firstPatternIdx < kArray_size(patternList)) {
kToken *firstPattern = patternList->TokenItems[firstPatternIdx];
if(kToken_isFirstPattern(firstPattern)) {
kNameSpace_AppendArrayRef(kctx, ns, &((kNameSpaceVar *)ns)->stmtPatternListNULL_OnList, UPCAST(firstPattern));
}
}
r = 1;
}
kStmt_done(kctx, stmt);
}
KReturnUnboxValue(r);
}
static KMETHOD Expression_Bracket(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_Expression(stmt, tokenList, beginIdx, operatorIdx, endIdx);
KonohaClass *genericsClass = NULL;
kNameSpace *ns = Stmt_ns(stmt);
int nextIdx = SUGAR TokenUtils_ParseTypePattern(kctx, ns, tokenList, beginIdx, endIdx, &genericsClass);
if(nextIdx != -1) { // to avoid Func[T]
KReturn(SUGAR kStmt_ParseOperatorExpr(kctx, stmt, tokenList->TokenItems[beginIdx]->resolvedSyntaxInfo, tokenList, beginIdx, beginIdx, endIdx));
}
kToken *currentToken = tokenList->TokenItems[operatorIdx];
if(beginIdx == operatorIdx) {
/* transform '[ Value1, Value2, ... ]' to '(Call Untyped new (Value1, Value2, ...))' */
DBG_ASSERT(currentToken->resolvedSyntaxInfo->keyword == KW_BracketGroup);
kExpr *arrayExpr = SUGAR new_UntypedCallStyleExpr(kctx, currentToken->resolvedSyntaxInfo, 2, currentToken, K_NULL);
KReturn(SUGAR kStmt_AddExprParam(kctx, stmt, arrayExpr, currentToken->subTokenList, 0, kArray_size(currentToken->subTokenList), NULL));
}
else {
kExpr *leftExpr = SUGAR kStmt_ParseExpr(kctx, stmt, tokenList, beginIdx, operatorIdx, NULL);
if(leftExpr == K_NULLEXPR) {
KReturn(leftExpr);
}
if(leftExpr->syn->keyword == SYM_("new")) { // new int[100], new int[]();
DBG_P("cur:%d, beg:%d, endIdx:%d", operatorIdx, beginIdx, endIdx);
size_t subTokenSize = kArray_size(currentToken->subTokenList);
if(subTokenSize == 0) {
/* transform 'new Type0 [ ]' => (Call Type0 new) */
kExpr_Setsyn(leftExpr, SYN_(ns, KW_ExprMethodCall));
} else {
/* transform 'new Type0 [ Type1 ] (...) => new 'Type0<Type1>' (...) */
KonohaClass *classT0 = NULL;
kArray *subTokenList = currentToken->subTokenList;
int beginIdx = -1;
if(kArray_size(subTokenList) > 0) {
beginIdx = SUGAR TokenUtils_ParseTypePattern(kctx, ns, subTokenList, 0, kArray_size(subTokenList), &classT0);
}
beginIdx = (beginIdx == -1) ? 0 : beginIdx;
kExpr_Setsyn(leftExpr, SYN_(ns, KW_ExprMethodCall));
DBG_P("currentToken->subtoken:%d", kArray_size(subTokenList));
leftExpr = SUGAR kStmt_AddExprParam(kctx, stmt, leftExpr, subTokenList, beginIdx, kArray_size(subTokenList), "[");
}
}
else {
/* transform 'Value0 [ Value1 ]=> (Call Value0 get (Value1)) */
kTokenVar *tkN = /*G*/new_(TokenVar, 0, OnGcStack);
tkN->resolvedSymbol= MN_toGETTER(0);
tkN->uline = currentToken->uline;
SugarSyntax *syn = SYN_(Stmt_ns(stmt), KW_ExprMethodCall);
leftExpr = SUGAR new_UntypedCallStyleExpr(kctx, syn, 2, tkN, leftExpr);
leftExpr = SUGAR kStmt_AddExprParam(kctx, stmt, leftExpr, currentToken->subTokenList, 0, kArray_size(currentToken->subTokenList), "[");
}
KReturn(SUGAR kStmt_RightJoinExpr(kctx, stmt, leftExpr, tokenList, operatorIdx + 1, endIdx));
}
}
ptr INT182_create_(ptr self__, int i__, ptr iset__)
{
ptr res__ = 0;
res__ = (ptr)new_(182,0);
IATT_(res__,4) = (int)i__;
PATT_(res__,12) = (ptr)iset__;
IATT_(res__,8) = (int)i__;
ret0__:
return (res__);
}
ptr ROU24_create_(ptr self__, ptr a__, ptr o__, ptr b__)
{
ptr res__ = 0;
res__ = (ptr)new_(24,0);
PATT_(res__,4) = (ptr)a__;
PATT_(res__,8) = (ptr)b__;
PATT_(res__,12) = (ptr)o__;
ret0__:
return (res__);
}
ptr ARE32_create_(ptr self__, ptr arr__, ptr inds__)
{
ptr res__ = 0;
res__ = (ptr)new_(32,0);
PATT_(res__,12) = (ptr)arr__;
PATT_(res__,16) = (ptr)inds__;
IATT_(res__,4) = (int)GLO68_curr_lineno_;
ret0__:
return (res__);
}
knh_InputStream_t* new_BytesInputStream(Ctx *ctx, knh_Bytes_t *ba)
{
knh_InputStream_t* in = new_(InputStream);
DBG_ASSERT(ba != ctx->bufa);
DP(in)->fd = IO_NULL;
KNH_SETv(ctx, DP(in)->ba, ba);
DP(in)->buf = (char*)(ba)->bu.ubuf;
DP(in)->bufsiz = BA_size(ba);
DP(in)->bufpos = 0;
DP(in)->bufend = BA_size(ba);
return in;
}
ptr ELS139_create_(ptr self__, ptr t__, ptr tp__, int ln__)
{
ptr res__ = 0;
res__ = (ptr)new_(139,0);
PATT_(res__,12) = (ptr)t__;
PATT_(res__,16) = (ptr)tp__;
IATT_(res__,4) = (int)ln__;
ret0__:
return (res__);
}
ptr SYM186_create_(ptr self__, int sz__, ptr cls__)
{
ptr res__ = 0;
res__ = (ptr)new_(186,0);
PATT_(res__,4) = (ptr)cls__;
PATT_(res__,8) = (ptr)LIS231_push_(LIS231_create_(0,4),HAS230_create_(0,20));
IATT_(res__,16) = (int)0;
PATT_(res__,12) = (ptr)LIS98_create_(PATT_(res__,12),20);
ret0__:
return (res__);
}
static kStmt* TypeDeclAndMakeSetter(KonohaContext *kctx, kStmt *stmt, kGamma *gma, ktype_t ty, kExpr *termExpr, kExpr *valueExpr, kObject *scr)
{
kNameSpace *ns = Stmt_ns(stmt);
kMethod *mtd = Object_newProtoSetterNULL(kctx, stmt, scr, ty, termExpr->termToken->resolvedSymbol);
if(mtd != NULL) {
kExpr *recvExpr = new_ConstValueExpr(kctx, O_typeId(scr), scr);
kExpr *setterExpr = SUGAR new_TypedCallExpr(kctx, stmt, gma, TY_void, mtd, 2, recvExpr, valueExpr);
kStmt *newstmt = new_(Stmt, stmt->uline, OnGcStack);
kStmt_setsyn(newstmt, SYN_(ns, KW_ExprPattern));
KLIB kObject_setObject(kctx, newstmt, KW_ExprPattern, TY_Expr, setterExpr);
return newstmt;
}
return NULL;
}
knh_InputStream_t* new_StringInputStream(Ctx *ctx, knh_String_t *str, size_t s, size_t e)
{
knh_InputStream_t* o = new_(InputStream);
DP(o)->fd = IO_NULL;
DBG_ASSERT(IS_String(str));
KNH_SETv(ctx, DP(o)->str, str);
DP(o)->buf = (char*)S_tochar(str);
DP(o)->bufsiz = S_size(str);
DBG_ASSERT(e <= S_size(str));
DBG_ASSERT(s <= e);
DP(o)->bufpos = s;
DP(o)->bufend = e;
return o;
}
static kException* new_Assertion(CTX ctx, kline_t uline)
{
kException* e = new_(Exception);
char buf[256] = {'A', 's', 's', 'e', 'r', 't', 'i', 'o', 'n', '!', '!', ':', ' '};
char *mbuf = buf + 13;
knh_readuline(ctx, uline, mbuf, sizeof(buf)-13);
if(mbuf[0] == 0) {
kuri_t uri = ULINE_uri(uline);
size_t line = ULINE_line(uline);
knh_snprintf(buf, sizeof(buf), "Assertion!!: %s at line %lu", FILENAME__(uri), line);
}
KNH_SETv(ctx, e->emsg, new_String2(ctx, CLASS_String, (const char*)buf, knh_strlen(buf), SPOL_ASCII));
e->uline = uline;
return e;
}
