imperium.keywords.json

/*------------------------------------------------------------------------*/
/* Each language must define the same number of abstract keywords as      */
/* English.                                                               */
/* Abbreviations for keywords are permitted by using a comma as the       */
/* separator, additional abbreviations are optional and need not be       */
/* present in the English dictionary.                                     */
/* The left hand names are standardized but always converted to upper     */
/* case when the grammar text is generated, these names are referenced    */
/* by the grammar's parsing rules.                                        */
/*------------------------------------------------------------------------*/

{

  "en": { // English
    "Alias": "alias",
    "Aligned": "aligned",
    "All": "all",
    "Any": "any",
    "Argument": "argument, arg",
    "As": "as",
    "Based": "based",
    "Binary": "binary, bin",
    "Bit": "bit",
    "Boolean": "boolean, bool",
    "Bootstrap": "bootstrap, boot",
    "Builtin": "builtin",
    "By": "by",
    "Bypass": "bypass",
    "Call": "call",
    "Character": "character, char",
    "Cofunction": "cofunction",
    "Cold":  "cold",
    "Coroutine": "coroutine",
    "Decimal": "decimal, dec",
    "Declare": "declare, dcl",
    "Define": "define, def",
    "Defined": "defined", // might want a better term. 'overlay' perhaps
    "Elif": "elif",
    "Else": "else",
    "Emit": "emit",
    "End": "end",
    "Endloop": "endloop",
    "Entry": "entry",
    "Enum": "enum",
    "Fixed": "fixed",
    "Float": "float",
    "Function": "function, func",
    "Goto": "goto, go to",
    "If": "if",
    "Inc": "inc",
    "Include": "include",
    "Internal": "internal",
    "Interrupt": "interrupt, isr",
    "Intrinsic": "intrinsic",
    "Language": "lingua",
    "Loop": "loop",
    "Main": "main",
    "Naked": "naked",
    "Noreturn": "noreturn",
    "Offset": "offset, ofx",
    "Otherwise": "otherwise",
    "Out": "out",
    "Pad": "pad",
    "Pointer": "pointer, ptr",
    "Private": "private",
    "Procedure": "procedure, proc",
    "Public": "public",
    "Raw": "raw",
    "Readonly": "readonly",
    "Recursive": "recursive, rec",
    "Ref": "ref",
    "Reloop": "reloop",
    "Retain": "retain",
    "Return": "return",
    "Returns": "returns",
    "Returnon": "returnon",
    "Scope": "scope",
    "Section": "section",
    "Select": "select",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "static",
    "String": "string",
    "Structure": "structure, struct",
    "Target": "target",
    "Then": "then",
    "To": "to",
    "Traits": "traits",
    "Type": "type",
    "Unaligned": "unaligned",
    "Until": "until",
    "Uses": "uses",
    "Using": "using",
    "Utf": "utf",
    "Variable": "variable",
    "Varying": "varying",
    "While": "while",
    "When": "when",
    "Yield": "yield"
  },

  "fr": { // French
    "Aligned": "aligné",
    "Argument": "argument",
    "Based": "based",
    "Binary": "binaire",
    "Bit": "bit",
    "Boolean": "booléenne",
    "Builtin": "intégré",
    "By": "by",
    "Bypass": "bypass",
    "Call": "appeler",
    "Character": "character",
    "Cofunction": "cofunction",
    "Coroutine": "coroutine",
    "Decimal": "décimal",
    "Declare": "déclarer",
    "Define": "define",
    "Defined": "defined",
    "Elif": "elif",
    "Else": "autre",
    "End": "fin",
    "Endloop": "endloop",
    "Entry": "entry",
    "Enum": "enum",
    "Fixed": "fixe",
    "Float": "flottant",
    "Function": "fonction",
    "Goto": "aller à",
    "If": "si",
    "Inc": "inc",
    "Include": "comprendre",
    "Internal": "interne",
    "Interrupt": "interrompre",
    "Intrinsic": "intrinsic",
    "Language": "lingua",
    "Loop": "boucle",
    "Namespace": "namespace",
    "Offset": "offset, ofx",
    "Out": "depuis",
    "Pad": "pad",
    "Pointer": "pointer",
    "Private": "privé",
    "Procedure": "procédé",
    "Public": "public",
    "Readonly": "readonly",
    "Ref": "ref",
    "Reloop": "reloop",
    "Return": "retour",
    "Returns": "retours",
    "Returnon": "retour_si",
    "Scope": "scope",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "static",
    "String": "chaîne",
    "Structure": "structure",
    "Then": "ensuite",
    "To": "to",
    "Type": "type",
    "Unaligned": "unaligned",
    "Until": "avant",
    "Using": "using",
    "While": "tandis que",
    "Variable": "variable",
    "Varying": "varying",
    "Yield": "donner"
  },

  "he": { // Hebrew
    "Aligned": "aligned",
    "Argument": "argument",
    "Binary": "binary",
    "Boolean": "boolean",
    "Builtin": "builtin",
    "By": "by",
    "Call": "call",
    "Coroutine": "coroutine",
    "Decimal": "decimal",
    "Declare": "declare",
    "Define": "define",
    "Else": "אחרת",
    "End": "end",
    "Enum": "enum",
    "Fixed": "fixed",
    "Float": "float",
    "Function": "function",
    "Goto": "goto",
    "If": "אם",
    "Internal": "internal",
    "Interrupt": "interrupt",
    "Language": "lingua",
    "Loop": "loop",
    "Offset": "offset, ofx",
    "Out": "out",
    "Pad": "pad",
    "Pointer": "pointer",
    "Private": "private",
    "Procedure": "procedure",
    "Public": "public",
    "Readonly": "readonly",
    "Ref": "ref",
    "Return": "return",
    "Returnon": "returnon",
    "Scope": "scope",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "static",
    "String": "string",
    "Structure": "structure",
    "To": "to",
    "Type": "type",
    "Unaligned": "unaligned",
    "Until": "until",
    "Using": "using",
    "While": "כלעוד",
    "Varying": "varying",
    "Yield": "yield"
  },

  "nl": { // Dutch
    "Argument": "argument",
    "Binary": "binair",
    "Boolean": "boolean",
    "Builtin": "ingebouwd",
    "By": "door",
    "Call": "aanroepen",
    "Coroutine": "co routine",
    "Decimal": "decimaal",
    "Declare": "declareer",
    "End": "einde",
    "Enum": "opsomming",
    "Fixed": "fixed",
    "Float": "float",
    "Function": "functie",
    "Goto": "ga",
    "If": "als",
    "Internal": "intern",
    "Interrupt": "interrupt",
    "Loop": "lus",
    "Out": "out",
    "Private": "private",
    "Procedure": "procedure",
    "Public": "publiek",
    "Readonly": "alleen lezen",
    "Ref": "referentie",
    "Return": "terug",
    "Returnon": "terug bij",
    "Scope": "scope",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "statisch",
    "String": "string",
    "Structure": "structuur",
    "To": "tot",
    "Type": "type",
    "Until": "totdat",
    "Using": "gebruikende",
    "While": "zolang",
    "Varying": "varierend",
    "Yield": "opbrengst"
  },

  "de": { // German
    "Aligned": "ausgerichtet",
    "Argument": "argument",
    "Based": "based",
    "Binary": "binär",
    "Bit": "bit",
    "Boolean": "boolesch",
    "Builtin": "eingebaut",
    "By": "by",
    "Bypass": "bypass",
    "Call": "aufrufen",
    "Character": "character",
    "Cofunction": "cofunction",
    "Coroutine": "coroutine",
    "Decimal": "dezimal",
    "Declare": "deklarieren",
    "Define": "define",
    "Defined": "defined",
    "Elif": "elif",
    "Else": "anders",
    "End": "ende",
    "Endloop": "ende wiederholen",
    "Entry": "entry",
    "Enum": "enum",
    "Fixed": "stationär",
    "Float": "flottant",
    "Function": "fonction",
    "Goto": "gehen",
    "If": "wenn",
    "Inc": "inc",
    "Include": "enthalten",
    "Internal": "intern",
    "Interrupt": "unterbrechen",
    "Intrinsic": "intrinsisch",
    "Language": "lingua",
    "Loop": "wiederholen",
    "Offset": "offset, ofx",
    "Out": "depuis",
    "Pad": "pad",
    "Pointer": "pointer",
    "Private": "privé",
    "Procedure": "routine",
    "Public": "öffentlich",
    "Readonly": "readonly",
    "Ref": "ref",
    "Reloop": "reloop",
    "Return": "rückkehr",
    "Returns": "rückkehrs",
    "Returnon": "retour_si",
    "Scope": "scope",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "static",
    "String": "text",
    "Structure": "structure",
    "Then": "dann",
    "To": "to",
    "Type": "art",
    "Unaligned": "unaligned",
    "Until": "bis",
    "Using": "using",
    "While": "solang",
    "Variable": "variable",
    "Varying": "varying",
    "Yield": "abtreten"
  },

  "ru": { // Russian
    "Aligned": "выровнены",
    "Argument": "argument, arg",
    "Based": "based",
    "Binary": "бинарный, bin",
    "Bit": "бит",
    "Boolean": "boolean, bool",
    "Builtin": "builtin",
    "By": "by",
    "Bypass": "bypass",
    "Call": "вызов",
    "Character": "character, char",
    "Cofunction": "cofunction",
    "Coroutine": "coroutine",
    "Decimal": "decimal, dec",
    "Declare": "объявлять, dcl",
    "Define": "define, def",
    "Defined": "defined",
    "Elif": "elif",
    "Else": "еще",
    "End": "конец",
    "Endloop": "endloop",
    "Entry": "entry",
    "Enum": "enum",
    "Fixed": "fixed",
    "Float": "float",
    "Function": "function, func",
    "Goto": "перейти к",
    "If": "если",
    "Inc": "inc",
    "Include": "include",
    "Internal": "internal",
    "Interrupt": "interrupt",
    "Intrinsic": "intrinsic",
    "Language": "lingua",
    "Loop": "повторять",
    "Offset": "offset, ofx",
    "Out": "out",
    "Pad": "pad",
    "Pointer": "pointer, ptr",
    "Private": "private",
    "Procedure": "процедура",
    "Public": "public",
    "Readonly": "readonly",
    "Ref": "ref",
    "Reloop": "reloop",
    "Return": "возврат",
    "Returns": "returns",
    "Returnon": "returnon",
    "Scope": "scope",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "static",
    "String": "string",
    "Structure": "structure, struct",
    "Then": "то",
    "To": "to",
    "Type": "type",
    "Unaligned": "unaligned",
    "Until": "пока",
    "Using": "using",
    "While": "в то время как",
    "Variable": "variable",
    "Varying": "varying",
    "Yield": "yield"
  },

  "bg": { // Bulgarian
    "Aligned": "выровнены",
    "Argument": "argument, arg",
    "Based": "based",
    "Binary": "двоичен",
    "Bit": "бит",
    "Boolean": "boolean, bool",
    "Builtin": "builtin",
    "By": "by",
    "Bypass": "bypass",
    "Call": "вызов",
    "Character": "character, char",
    "Cofunction": "cofunction",
    "Coroutine": "coroutine",
    "Decimal": "decimal, dec",
    "Declare": "обявявам",
    "Define": "define, def",
    "Defined": "defined",
    "Elif": "elif",
    "Else": "друго",
    "End": "конец",
    "Endloop": "endloop",
    "Entry": "entry",
    "Enum": "enum",
    "Fixed": "fixed",
    "Float": "float",
    "Function": "function, func",
    "Goto": "перейти к",
    "If": "ако",
    "Inc": "inc",
    "Include": "include",
    "Internal": "internal",
    "Interrupt": "interrupt",
    "Intrinsic": "intrinsic",
    "Language": "lingua",
    "Loop": "повторете",
    "Offset": "offset, ofx",
    "Out": "out",
    "Pad": "pad",
    "Pointer": "pointer, ptr",
    "Private": "private",
    "Procedure": "процедура",
    "Public": "public",
    "Readonly": "readonly",
    "Ref": "ref",
    "Reloop": "reloop",
    "Return": "возврат",
    "Returns": "returns",
    "Returnon": "returnon",
    "Scope": "scope",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "static",
    "String": "string",
    "Structure": "structure, struct",
    "Then": "тогава",
    "To": "to",
    "Type": "type",
    "Unaligned": "unaligned",
    "Until": "пока",
    "Using": "using",
    "While": "докато",
    "Variable": "variable",
    "Varying": "varying",
    "Yield": "yield"
  },

  "da": { // English
    "Aligned": "justeret",
    "Argument": "argument, arg",
    "Based": "based",
    "Binary": "binær, bin",
    "Bit": "bit",
    "Boolean": "boolesk, bool",
    "Builtin": "builtin",
    "By": "by",
    "Bypass": "bypass",
    "Call": "påberåbe sig",
    "Character": "character, char",
    "Cofunction": "cofunction",
    "Coroutine": "coroutine",
    "Decimal": "decimal, dec",
    "Declare": "erklære, dcl",
    "Define": "define, def",
    "Defined": "defined",
    "Elif": "elif",
    "Else": "andet",
    "End": "ende",
    "Endloop": "endloop",
    "Entry": "entry",
    "Enum": "enum",
    "Fixed": "fixed",
    "Float": "float",
    "Function": "function, func",
    "Goto": "goto, go to",
    "If": "hvis",
    "Inc": "inc",
    "Include": "include",
    "Internal": "internal",
    "Interrupt": "interrupt",
    "Intrinsic": "intrinsic",
    "Language": "lingua",
    "Loop": "gentage",
    "Offset": "offset, ofx",
    "Out": "out",
    "Pad": "pad",
    "Pointer": "pointer, ptr",
    "Private": "private",
    "Procedure": "procedure, proc",
    "Public": "public",
    "Readonly": "readonly",
    "Ref": "ref",
    "Reloop": "reloop",
    "Return": "vende tilbage",
    "Returns": "returns",
    "Returnon": "returnon",
    "Scope": "scope",
    "Singlet": "singlet",
    "Stack": "stack",
    "Static": "static",
    "String": "string",
    "Structure": "structure, struct",
    "Then": "derefter",
    "To": "to",
    "Type": "type",
    "Unaligned": "unaligned",
    "Until": "indtil, til",
    "Using": "using",
    "While": "mens",
    "Variable": "variable",
    "Varying": "varying",
    "Yield": "overdrage"
  }
}