[카테고리:] Software

Prism.languages.modelica=
Prism.languages.extend("cpp",
{
    keyword:
    /\b(?:algorithm|and|annotation|block|break|class|connect|connector|constant|constrainedby|der|discrete|each|elseif|elsewhen|encapsulated|end|enumeration|equation|expandable|extends|external|false|final|flow|for|function|if|import|impure|in|initial|inner|input|loop|model|not|operator|or|outer|output|package|parameter|partial|protected|public|pure|record|redeclare|replaceable|return|stream|then|true|type|when|while|within)\b/,

}),

;

Prism.languages.c=
Prism.languages.extend("clike",
{ 

keyword:
/\b(?:
_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while
)\b

/,
operator:
/>>=?
|<<=?
|->
|([-+&|:])\1
|[?:~]
|[-+*\/%&|^!=<>]=?

/,
number:
/(?:
\b0x[\da-f]+
|(?:\b\d+\.?\d*
|\B\.\d+)(?:e[+-]?\d+)?)[ful]*/i}
),

Prism.languages.insertBefore
("c",

"string",

{
    macro:
    {
        pattern:/(^\s*)#\s*[a-z]+(?:[^\r\n\\]|\\(?:\r\n|[\s\S]))*/im,
        lookbehind:!0,
        alias:"property",
        inside:
        {
            string:
            {
                pattern:
                /(#\s*include\s*)(?:<.+?>|("|')(?:\\?.)+?\2)/,

                lookbehind:
                !0
            },

            directive:
            {
                pattern:/(#\s*)
                \b(?:define|defined|elif|else|endif|error|ifdef|ifndef|if|import|
                include|line|pragma|undef|using
                )\b/,

                lookbehind:
                !0,

                alias:
                "keyword"
            }
        }
    },

    constant:

    /\b(?:
    __FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|
    SEEK_CUR|SEEK_END|SEEK_SET|stdin|stdout|stderr
    )\b

/}
)

,delete 

Prism.languages.c["class-name"]
,delete 

Prism.languages.c["boolean"];

Prism.languages.cpp=
Prism.languages.extend("c",
{
    keyword:
    /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,

    "boolean":
    /\b(?:true|false)\b/,

    operator:   
    />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*\/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/


}),

Prism.languages.insertBefore(
"cpp",
"keyword",

{
    "class-name":
    {
        pattern:
        /(class\s+)\w+/i,

        lookbehind:
        !0
    }
}),

Prism.languages.insertBefore(
"cpp",
"string",

{
    "raw-string":
    {
        pattern:
        /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
        alias:"string",
        greedy:!0
    }
});

comment:
/\/\*[\s\S]*?\*\/

/,
atrule:
{
    pattern:
    /@[\w-]+?.*?(?:;|(?=\s*\{))/i,

    inside:
    {
        rule:
        /@[\w-]+/}},

        url:
        /url\((?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|.*?)\)/i,

        selector:
        /[^{}\s][^{};]*?(?=\s*\{)/,

        string:
        {
            pattern:
            /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,

            greedy:
            !0
        },

        property:
        /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,

        important:
        /!important\b/i,"function":/[-a-z0-9]+(?=\()/i,

        punctuation:/[(){};:,]
    /},

    Prism.languages.css.atrule.inside.rest=Prism.languages.css,
    Prism.languages.markup&&(
    Prism.languages.insertBefore
    ("markup",
    "tag",

    {
        style:
        {
            pattern:/(<style[\s\S]*?>)[\s\S]*?(?=<\/style>)/i,
            lookbehind:!0,inside:Prism.languages.css,
            alias:"language-css",
            greedy:!0
        }
    }),

    Prism.languages.insertBefore
    ("inside",
    "attr-value",

    {
        "style-attr":
        {
            pattern:/\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
            inside:{"attr-name":
            {
                pattern:/^\s*style/i,
                inside:Prism.languages.markup.tag.inside
            },
        punctuation:/^\s*=\s*['"]|['"]\s*$/,"attr-value":
        {
            pattern:/.+/i,inside:Prism.languages.css
        }
    },
    alias:"language-css"}},Prism.languages.markup.tag));

Prism.languages.clike=
{
    comment:[
    {
        pattern:/(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
        lookbehind:!0
    },
    {
        pattern:/(^|[^\\:])\/\/.*/,
        lookbehind:!0,
        greedy:!0
    }],

    string:
    {
        pattern:/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
        greedy:!0
    },

    "class-name":
    {
        pattern:
        /((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,

        lookbehind:
        !0,

        inside:
        {
            punctuation:
            /[.\\]/
        }
    },

    keyword:
                /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,"boolean":/\b(?:true|false)\b/,"function":/\w+(?=\()/,

    number:
    /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,

    operator:
    /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,

    punctuation:
    /[{}[\];(),.:]/
};